
#include "convertIPCPValueToPA.h"
#include <arpa/inet.h>
#include <string.h>
#include "vp/SignalServiceId.h"
#include "ap/signal_id.h"

#include "vp/ApVpPulse.h"
#include "vp/AudioRadio.h"
#include "vp/Climate.h"
#include "vp/DiagDID.h"
#include "vp/DiagOTA.h"
#include "vp/DiagProxy.h"
#include "vp/DiagVFC.h"
#include "vp/ECVersion.h"
#include "vp/ExtAmpCtrl.h"
#include "vp/McuLogPanic.h"
#include "vp/Power.h"
#include "vp/ServiceReminder.h"
#include "vp/SwcOdoOfTripInfo.h"
#include "vp/VFCIPWakeup.h"
#include "vp/VIN.h"
#include "vp/VINDiffMsg.h"
#include "vp/VPVersion.h"

namespace ecarx::transfer::utils{

    
    std::vector<Signal> ipcpToPASignals(const ipcp::IpcpValue& ipValue){

        std::vector<Signal> signals={};
        switch(ipValue.service_id){
            
            case EcarXSignalServiceID::serviceID_APVPPULSE:{
                
                constexpr int structLen=(int)sizeof(OpApVpPulse_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpApVpPulse_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal paerrorreportSignal;
                paerrorreportSignal.signalId = (int32_t)PASignal::PA_ErrorReport;
                paerrorreportSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paerrorreport;
                //成员赋值
                paerrorreport.availability = ntohl(data.paerrorreport.availability);
                paerrorreport.data = ntohl(data.paerrorreport.data);
                paerrorreport.format = ntohl(data.paerrorreport.format);
                paerrorreport.status = ntohl(data.paerrorreport.status);
                memcpy(paerrorreportSignal.value.bytes.data(),&paerrorreport, sizeof(PAIntFuncType));
                signals.emplace_back(paerrorreportSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_AUDIORADIO:{
                
                constexpr int structLen=(int)sizeof(OpAudioRadio_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpAudioRadio_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal paarwarningvloSignal;
                paarwarningvloSignal.signalId = (int32_t)PASignal::PA_AR_WarningVlo;
                paarwarningvloSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paarwarningvlo;
                //成员赋值
                paarwarningvlo.availability = ntohl(data.paarwarningvlo.availability);
                paarwarningvlo.data = ntohl(data.paarwarningvlo.data);
                paarwarningvlo.format = ntohl(data.paarwarningvlo.format);
                paarwarningvlo.status = ntohl(data.paarwarningvlo.status);
                memcpy(paarwarningvloSignal.value.bytes.data(),&paarwarningvlo, sizeof(PAIntFuncType));
                signals.emplace_back(paarwarningvloSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_CLIMATE:{
                
                constexpr int structLen=(int)sizeof(OpClimate_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(44);
                OpClimate_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal paclacSignal;
                paclacSignal.signalId = (int32_t)PASignal::PA_CL_AC;
                paclacSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclac;
                //成员赋值
                paclac.availability = ntohl(data.paclac.availability);
                paclac.data = ntohl(data.paclac.data);
                paclac.format = ntohl(data.paclac.format);
                paclac.status = ntohl(data.paclac.status);
                memcpy(paclacSignal.value.bytes.data(),&paclac, sizeof(PAIntFuncType));
                signals.emplace_back(paclacSignal);
                Signal paclautoSignal;
                paclautoSignal.signalId = (int32_t)PASignal::PA_CL_Auto;
                paclautoSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclauto;
                //成员赋值
                paclauto.availability = ntohl(data.paclauto.availability);
                paclauto.data = ntohl(data.paclauto.data);
                paclauto.format = ntohl(data.paclauto.format);
                paclauto.status = ntohl(data.paclauto.status);
                memcpy(paclautoSignal.value.bytes.data(),&paclauto, sizeof(PAIntFuncType));
                signals.emplace_back(paclautoSignal);
                Signal paclrecircSignal;
                paclrecircSignal.signalId = (int32_t)PASignal::PA_CL_Recirc;
                paclrecircSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclrecirc;
                //成员赋值
                paclrecirc.availability = ntohl(data.paclrecirc.availability);
                paclrecirc.data = ntohl(data.paclrecirc.data);
                paclrecirc.format = ntohl(data.paclrecirc.format);
                paclrecirc.status = ntohl(data.paclrecirc.status);
                memcpy(paclrecircSignal.value.bytes.data(),&paclrecirc, sizeof(PAIntFuncType));
                signals.emplace_back(paclrecircSignal);
                Signal paclmodefrstleftSignal;
                paclmodefrstleftSignal.signalId = (int32_t)PASignal::PA_CL_ModeFrstLeft;
                paclmodefrstleftSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclmodefrstleft;
                //成员赋值
                paclmodefrstleft.availability = ntohl(data.paclmodefrstleft.availability);
                paclmodefrstleft.data = ntohl(data.paclmodefrstleft.data);
                paclmodefrstleft.format = ntohl(data.paclmodefrstleft.format);
                paclmodefrstleft.status = ntohl(data.paclmodefrstleft.status);
                memcpy(paclmodefrstleftSignal.value.bytes.data(),&paclmodefrstleft, sizeof(PAIntFuncType));
                signals.emplace_back(paclmodefrstleftSignal);
                Signal paclmodefrstrightSignal;
                paclmodefrstrightSignal.signalId = (int32_t)PASignal::PA_CL_ModeFrstRight;
                paclmodefrstrightSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclmodefrstright;
                //成员赋值
                paclmodefrstright.availability = ntohl(data.paclmodefrstright.availability);
                paclmodefrstright.data = ntohl(data.paclmodefrstright.data);
                paclmodefrstright.format = ntohl(data.paclmodefrstright.format);
                paclmodefrstright.status = ntohl(data.paclmodefrstright.status);
                memcpy(paclmodefrstrightSignal.value.bytes.data(),&paclmodefrstright, sizeof(PAIntFuncType));
                signals.emplace_back(paclmodefrstrightSignal);
                Signal paclmodesecSignal;
                paclmodesecSignal.signalId = (int32_t)PASignal::PA_CL_ModeSec;
                paclmodesecSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclmodesec;
                //成员赋值
                paclmodesec.availability = ntohl(data.paclmodesec.availability);
                paclmodesec.data = ntohl(data.paclmodesec.data);
                paclmodesec.format = ntohl(data.paclmodesec.format);
                paclmodesec.status = ntohl(data.paclmodesec.status);
                memcpy(paclmodesecSignal.value.bytes.data(),&paclmodesec, sizeof(PAIntFuncType));
                signals.emplace_back(paclmodesecSignal);
                Signal paclmaxacSignal;
                paclmaxacSignal.signalId = (int32_t)PASignal::PA_CL_MaxAC;
                paclmaxacSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclmaxac;
                //成员赋值
                paclmaxac.availability = ntohl(data.paclmaxac.availability);
                paclmaxac.data = ntohl(data.paclmaxac.data);
                paclmaxac.format = ntohl(data.paclmaxac.format);
                paclmaxac.status = ntohl(data.paclmaxac.status);
                memcpy(paclmaxacSignal.value.bytes.data(),&paclmaxac, sizeof(PAIntFuncType));
                signals.emplace_back(paclmaxacSignal);
                Signal paclfanlevelSignal;
                paclfanlevelSignal.signalId = (int32_t)PASignal::PA_CL_FanLevel;
                paclfanlevelSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclfanlevel;
                //成员赋值
                paclfanlevel.availability = ntohl(data.paclfanlevel.availability);
                paclfanlevel.data = ntohl(data.paclfanlevel.data);
                paclfanlevel.format = ntohl(data.paclfanlevel.format);
                paclfanlevel.status = ntohl(data.paclfanlevel.status);
                memcpy(paclfanlevelSignal.value.bytes.data(),&paclfanlevel, sizeof(PAIntFuncType));
                signals.emplace_back(paclfanlevelSignal);
                Signal pacllefttempSignal;
                pacllefttempSignal.signalId = (int32_t)PASignal::PA_CL_LeftTemp;
                pacllefttempSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pacllefttemp;
                //成员赋值
                pacllefttemp.availability = ntohl(data.pacllefttemp.availability);
                pacllefttemp.data = ntohl(data.pacllefttemp.data);
                pacllefttemp.format = ntohl(data.pacllefttemp.format);
                pacllefttemp.status = ntohl(data.pacllefttemp.status);
                memcpy(pacllefttempSignal.value.bytes.data(),&pacllefttemp, sizeof(PAIntFuncType));
                signals.emplace_back(pacllefttempSignal);
                Signal paclrighttempSignal;
                paclrighttempSignal.signalId = (int32_t)PASignal::PA_CL_RightTemp;
                paclrighttempSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclrighttemp;
                //成员赋值
                paclrighttemp.availability = ntohl(data.paclrighttemp.availability);
                paclrighttemp.data = ntohl(data.paclrighttemp.data);
                paclrighttemp.format = ntohl(data.paclrighttemp.format);
                paclrighttemp.status = ntohl(data.paclrighttemp.status);
                memcpy(paclrighttempSignal.value.bytes.data(),&paclrighttemp, sizeof(PAIntFuncType));
                signals.emplace_back(paclrighttempSignal);
                Signal paclmaxdefrostSignal;
                paclmaxdefrostSignal.signalId = (int32_t)PASignal::PA_CL_MaxDefrost;
                paclmaxdefrostSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclmaxdefrost;
                //成员赋值
                paclmaxdefrost.availability = ntohl(data.paclmaxdefrost.availability);
                paclmaxdefrost.data = ntohl(data.paclmaxdefrost.data);
                paclmaxdefrost.format = ntohl(data.paclmaxdefrost.format);
                paclmaxdefrost.status = ntohl(data.paclmaxdefrost.status);
                memcpy(paclmaxdefrostSignal.value.bytes.data(),&paclmaxdefrost, sizeof(PAIntFuncType));
                signals.emplace_back(paclmaxdefrostSignal);
                Signal pawdcautofrontdefrostSignal;
                pawdcautofrontdefrostSignal.signalId = (int32_t)PASignal::PA_WDC_AutoFrontDefrost;
                pawdcautofrontdefrostSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pawdcautofrontdefrost;
                //成员赋值
                pawdcautofrontdefrost.availability = ntohl(data.pawdcautofrontdefrost.availability);
                pawdcautofrontdefrost.data = ntohl(data.pawdcautofrontdefrost.data);
                pawdcautofrontdefrost.format = ntohl(data.pawdcautofrontdefrost.format);
                pawdcautofrontdefrost.status = ntohl(data.pawdcautofrontdefrost.status);
                memcpy(pawdcautofrontdefrostSignal.value.bytes.data(),&pawdcautofrontdefrost, sizeof(PAIntFuncType));
                signals.emplace_back(pawdcautofrontdefrostSignal);
                Signal pawdcautoreardefrostSignal;
                pawdcautoreardefrostSignal.signalId = (int32_t)PASignal::PA_WDC_AutoRearDefrost;
                pawdcautoreardefrostSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pawdcautoreardefrost;
                //成员赋值
                pawdcautoreardefrost.availability = ntohl(data.pawdcautoreardefrost.availability);
                pawdcautoreardefrost.data = ntohl(data.pawdcautoreardefrost.data);
                pawdcautoreardefrost.format = ntohl(data.pawdcautoreardefrost.format);
                pawdcautoreardefrost.status = ntohl(data.pawdcautoreardefrost.status);
                memcpy(pawdcautoreardefrostSignal.value.bytes.data(),&pawdcautoreardefrost, sizeof(PAIntFuncType));
                signals.emplace_back(pawdcautoreardefrostSignal);
                Signal paclfrontdefrostSignal;
                paclfrontdefrostSignal.signalId = (int32_t)PASignal::PA_CL_FrontDefrost;
                paclfrontdefrostSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclfrontdefrost;
                //成员赋值
                paclfrontdefrost.availability = ntohl(data.paclfrontdefrost.availability);
                paclfrontdefrost.data = ntohl(data.paclfrontdefrost.data);
                paclfrontdefrost.format = ntohl(data.paclfrontdefrost.format);
                paclfrontdefrost.status = ntohl(data.paclfrontdefrost.status);
                memcpy(paclfrontdefrostSignal.value.bytes.data(),&paclfrontdefrost, sizeof(PAIntFuncType));
                signals.emplace_back(paclfrontdefrostSignal);
                Signal paclreardefrostSignal;
                paclreardefrostSignal.signalId = (int32_t)PASignal::PA_CL_RearDefrost;
                paclreardefrostSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclreardefrost;
                //成员赋值
                paclreardefrost.availability = ntohl(data.paclreardefrost.availability);
                paclreardefrost.data = ntohl(data.paclreardefrost.data);
                paclreardefrost.format = ntohl(data.paclreardefrost.format);
                paclreardefrost.status = ntohl(data.paclreardefrost.status);
                memcpy(paclreardefrostSignal.value.bytes.data(),&paclreardefrost, sizeof(PAIntFuncType));
                signals.emplace_back(paclreardefrostSignal);
                Signal paclsyncSignal;
                paclsyncSignal.signalId = (int32_t)PASignal::PA_CL_Sync;
                paclsyncSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclsync;
                //成员赋值
                paclsync.availability = ntohl(data.paclsync.availability);
                paclsync.data = ntohl(data.paclsync.data);
                paclsync.format = ntohl(data.paclsync.format);
                paclsync.status = ntohl(data.paclsync.status);
                memcpy(paclsyncSignal.value.bytes.data(),&paclsync, sizeof(PAIntFuncType));
                signals.emplace_back(paclsyncSignal);
                Signal paclairctrloffSignal;
                paclairctrloffSignal.signalId = (int32_t)PASignal::PA_CL_AirCtrlOff;
                paclairctrloffSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclairctrloff;
                //成员赋值
                paclairctrloff.availability = ntohl(data.paclairctrloff.availability);
                paclairctrloff.data = ntohl(data.paclairctrloff.data);
                paclairctrloff.format = ntohl(data.paclairctrloff.format);
                paclairctrloff.status = ntohl(data.paclairctrloff.status);
                memcpy(paclairctrloffSignal.value.bytes.data(),&paclairctrloff, sizeof(PAIntFuncType));
                signals.emplace_back(paclairctrloffSignal);
                Signal paclhvacrectrSignal;
                paclhvacrectrSignal.signalId = (int32_t)PASignal::PA_CL_HvacReCtr;
                paclhvacrectrSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclhvacrectr;
                //成员赋值
                paclhvacrectr.availability = ntohl(data.paclhvacrectr.availability);
                paclhvacrectr.data = ntohl(data.paclhvacrectr.data);
                paclhvacrectr.format = ntohl(data.paclhvacrectr.format);
                paclhvacrectr.status = ntohl(data.paclhvacrectr.status);
                memcpy(paclhvacrectrSignal.value.bytes.data(),&paclhvacrectr, sizeof(PAIntFuncType));
                signals.emplace_back(paclhvacrectrSignal);
                Signal paclseclefttempSignal;
                paclseclefttempSignal.signalId = (int32_t)PASignal::PA_CL_SecLeftTemp;
                paclseclefttempSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclseclefttemp;
                //成员赋值
                paclseclefttemp.availability = ntohl(data.paclseclefttemp.availability);
                paclseclefttemp.data = ntohl(data.paclseclefttemp.data);
                paclseclefttemp.format = ntohl(data.paclseclefttemp.format);
                paclseclefttemp.status = ntohl(data.paclseclefttemp.status);
                memcpy(paclseclefttempSignal.value.bytes.data(),&paclseclefttemp, sizeof(PAIntFuncType));
                signals.emplace_back(paclseclefttempSignal);
                Signal paclsecrighttempSignal;
                paclsecrighttempSignal.signalId = (int32_t)PASignal::PA_CL_SecRightTemp;
                paclsecrighttempSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclsecrighttemp;
                //成员赋值
                paclsecrighttemp.availability = ntohl(data.paclsecrighttemp.availability);
                paclsecrighttemp.data = ntohl(data.paclsecrighttemp.data);
                paclsecrighttemp.format = ntohl(data.paclsecrighttemp.format);
                paclsecrighttemp.status = ntohl(data.paclsecrighttemp.status);
                memcpy(paclsecrighttempSignal.value.bytes.data(),&paclsecrighttemp, sizeof(PAIntFuncType));
                signals.emplace_back(paclsecrighttempSignal);
                Signal paclsecfanlevelSignal;
                paclsecfanlevelSignal.signalId = (int32_t)PASignal::PA_CL_SecFanLevel;
                paclsecfanlevelSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclsecfanlevel;
                //成员赋值
                paclsecfanlevel.availability = ntohl(data.paclsecfanlevel.availability);
                paclsecfanlevel.data = ntohl(data.paclsecfanlevel.data);
                paclsecfanlevel.format = ntohl(data.paclsecfanlevel.format);
                paclsecfanlevel.status = ntohl(data.paclsecfanlevel.status);
                memcpy(paclsecfanlevelSignal.value.bytes.data(),&paclsecfanlevel, sizeof(PAIntFuncType));
                signals.emplace_back(paclsecfanlevelSignal);
                Signal paclventilationSignal;
                paclventilationSignal.signalId = (int32_t)PASignal::PA_CL_Ventilation;
                paclventilationSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclventilation;
                //成员赋值
                paclventilation.availability = ntohl(data.paclventilation.availability);
                paclventilation.data = ntohl(data.paclventilation.data);
                paclventilation.format = ntohl(data.paclventilation.format);
                paclventilation.status = ntohl(data.paclventilation.status);
                memcpy(paclventilationSignal.value.bytes.data(),&paclventilation, sizeof(PAIntFuncType));
                signals.emplace_back(paclventilationSignal);
                Signal paclfrntdefrostpopupSignal;
                paclfrntdefrostpopupSignal.signalId = (int32_t)PASignal::PA_CL_FrntDefrostPopup;
                paclfrntdefrostpopupSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclfrntdefrostpopup;
                //成员赋值
                paclfrntdefrostpopup.availability = ntohl(data.paclfrntdefrostpopup.availability);
                paclfrntdefrostpopup.data = ntohl(data.paclfrntdefrostpopup.data);
                paclfrntdefrostpopup.format = ntohl(data.paclfrntdefrostpopup.format);
                paclfrntdefrostpopup.status = ntohl(data.paclfrntdefrostpopup.status);
                memcpy(paclfrntdefrostpopupSignal.value.bytes.data(),&paclfrntdefrostpopup, sizeof(PAIntFuncType));
                signals.emplace_back(paclfrntdefrostpopupSignal);
                Signal paclreardefrostpopupSignal;
                paclreardefrostpopupSignal.signalId = (int32_t)PASignal::PA_CL_RearDefrostPopup;
                paclreardefrostpopupSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclreardefrostpopup;
                //成员赋值
                paclreardefrostpopup.availability = ntohl(data.paclreardefrostpopup.availability);
                paclreardefrostpopup.data = ntohl(data.paclreardefrostpopup.data);
                paclreardefrostpopup.format = ntohl(data.paclreardefrostpopup.format);
                paclreardefrostpopup.status = ntohl(data.paclreardefrostpopup.status);
                memcpy(paclreardefrostpopupSignal.value.bytes.data(),&paclreardefrostpopup, sizeof(PAIntFuncType));
                signals.emplace_back(paclreardefrostpopupSignal);
                Signal paclsecrowonoffswithSignal;
                paclsecrowonoffswithSignal.signalId = (int32_t)PASignal::PA_CL_SecRowOnOffSwith;
                paclsecrowonoffswithSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclsecrowonoffswith;
                //成员赋值
                paclsecrowonoffswith.availability = ntohl(data.paclsecrowonoffswith.availability);
                paclsecrowonoffswith.data = ntohl(data.paclsecrowonoffswith.data);
                paclsecrowonoffswith.format = ntohl(data.paclsecrowonoffswith.format);
                paclsecrowonoffswith.status = ntohl(data.paclsecrowonoffswith.status);
                memcpy(paclsecrowonoffswithSignal.value.bytes.data(),&paclsecrowonoffswith, sizeof(PAIntFuncType));
                signals.emplace_back(paclsecrowonoffswithSignal);
                Signal paclintelliclimapopSignal;
                paclintelliclimapopSignal.signalId = (int32_t)PASignal::PA_CL_IntelliClimaPop;
                paclintelliclimapopSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclintelliclimapop;
                //成员赋值
                paclintelliclimapop.availability = ntohl(data.paclintelliclimapop.availability);
                paclintelliclimapop.data = ntohl(data.paclintelliclimapop.data);
                paclintelliclimapop.format = ntohl(data.paclintelliclimapop.format);
                paclintelliclimapop.status = ntohl(data.paclintelliclimapop.status);
                memcpy(paclintelliclimapopSignal.value.bytes.data(),&paclintelliclimapop, sizeof(PAIntFuncType));
                signals.emplace_back(paclintelliclimapopSignal);
                Signal paclclmsmtambientpopSignal;
                paclclmsmtambientpopSignal.signalId = (int32_t)PASignal::PA_CL_ClmSmtAmbientPop;
                paclclmsmtambientpopSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclclmsmtambientpop;
                //成员赋值
                paclclmsmtambientpop.availability = ntohl(data.paclclmsmtambientpop.availability);
                paclclmsmtambientpop.data = ntohl(data.paclclmsmtambientpop.data);
                paclclmsmtambientpop.format = ntohl(data.paclclmsmtambientpop.format);
                paclclmsmtambientpop.status = ntohl(data.paclclmsmtambientpop.status);
                memcpy(paclclmsmtambientpopSignal.value.bytes.data(),&paclclmsmtambientpop, sizeof(PAIntFuncType));
                signals.emplace_back(paclclmsmtambientpopSignal);
                Signal paclclmsmtclosecpopSignal;
                paclclmsmtclosecpopSignal.signalId = (int32_t)PASignal::PA_CL_ClmSmtCloSecPop;
                paclclmsmtclosecpopSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclclmsmtclosecpop;
                //成员赋值
                paclclmsmtclosecpop.availability = ntohl(data.paclclmsmtclosecpop.availability);
                paclclmsmtclosecpop.data = ntohl(data.paclclmsmtclosecpop.data);
                paclclmsmtclosecpop.format = ntohl(data.paclclmsmtclosecpop.format);
                paclclmsmtclosecpop.status = ntohl(data.paclclmsmtclosecpop.status);
                memcpy(paclclmsmtclosecpopSignal.value.bytes.data(),&paclclmsmtclosecpop, sizeof(PAIntFuncType));
                signals.emplace_back(paclclmsmtclosecpopSignal);
                Signal paclclmsmtclopasspopSignal;
                paclclmsmtclopasspopSignal.signalId = (int32_t)PASignal::PA_CL_ClmSmtCloPassPop;
                paclclmsmtclopasspopSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclclmsmtclopasspop;
                //成员赋值
                paclclmsmtclopasspop.availability = ntohl(data.paclclmsmtclopasspop.availability);
                paclclmsmtclopasspop.data = ntohl(data.paclclmsmtclopasspop.data);
                paclclmsmtclopasspop.format = ntohl(data.paclclmsmtclopasspop.format);
                paclclmsmtclopasspop.status = ntohl(data.paclclmsmtclopasspop.status);
                memcpy(paclclmsmtclopasspopSignal.value.bytes.data(),&paclclmsmtclopasspop, sizeof(PAIntFuncType));
                signals.emplace_back(paclclmsmtclopasspopSignal);
                Signal paclseclockclimaswSignal;
                paclseclockclimaswSignal.signalId = (int32_t)PASignal::PA_CL_SecLockClimaSw;
                paclseclockclimaswSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclseclockclimasw;
                //成员赋值
                paclseclockclimasw.availability = ntohl(data.paclseclockclimasw.availability);
                paclseclockclimasw.data = ntohl(data.paclseclockclimasw.data);
                paclseclockclimasw.format = ntohl(data.paclseclockclimasw.format);
                paclseclockclimasw.status = ntohl(data.paclseclockclimasw.status);
                memcpy(paclseclockclimaswSignal.value.bytes.data(),&paclseclockclimasw, sizeof(PAIntFuncType));
                signals.emplace_back(paclseclockclimaswSignal);
                Signal paclsecautoswSignal;
                paclsecautoswSignal.signalId = (int32_t)PASignal::PA_CL_SecAutoSw;
                paclsecautoswSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclsecautosw;
                //成员赋值
                paclsecautosw.availability = ntohl(data.paclsecautosw.availability);
                paclsecautosw.data = ntohl(data.paclsecautosw.data);
                paclsecautosw.format = ntohl(data.paclsecautosw.format);
                paclsecautosw.status = ntohl(data.paclsecautosw.status);
                memcpy(paclsecautoswSignal.value.bytes.data(),&paclsecautosw, sizeof(PAIntFuncType));
                signals.emplace_back(paclsecautoswSignal);
                Signal paclgcleanSignal;
                paclgcleanSignal.signalId = (int32_t)PASignal::PA_CL_GClean;
                paclgcleanSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclgclean;
                //成员赋值
                paclgclean.availability = ntohl(data.paclgclean.availability);
                paclgclean.data = ntohl(data.paclgclean.data);
                paclgclean.format = ntohl(data.paclgclean.format);
                paclgclean.status = ntohl(data.paclgclean.status);
                memcpy(paclgcleanSignal.value.bytes.data(),&paclgclean, sizeof(PAIntFuncType));
                signals.emplace_back(paclgcleanSignal);
                Signal paclsecclimaautoswithSignal;
                paclsecclimaautoswithSignal.signalId = (int32_t)PASignal::PA_CL_SecClimaAutoSwith;
                paclsecclimaautoswithSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclsecclimaautoswith;
                //成员赋值
                paclsecclimaautoswith.availability = ntohl(data.paclsecclimaautoswith.availability);
                paclsecclimaautoswith.data = ntohl(data.paclsecclimaautoswith.data);
                paclsecclimaautoswith.format = ntohl(data.paclsecclimaautoswith.format);
                paclsecclimaautoswith.status = ntohl(data.paclsecclimaautoswith.status);
                memcpy(paclsecclimaautoswithSignal.value.bytes.data(),&paclsecclimaautoswith, sizeof(PAIntFuncType));
                signals.emplace_back(paclsecclimaautoswithSignal);
                Signal paclintelliclimaegysavepopSignal;
                paclintelliclimaegysavepopSignal.signalId = (int32_t)PASignal::PA_CL_IntelliClimaEgySavePop;
                paclintelliclimaegysavepopSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclintelliclimaegysavepop;
                //成员赋值
                paclintelliclimaegysavepop.availability = ntohl(data.paclintelliclimaegysavepop.availability);
                paclintelliclimaegysavepop.data = ntohl(data.paclintelliclimaegysavepop.data);
                paclintelliclimaegysavepop.format = ntohl(data.paclintelliclimaegysavepop.format);
                paclintelliclimaegysavepop.status = ntohl(data.paclintelliclimaegysavepop.status);
                memcpy(paclintelliclimaegysavepopSignal.value.bytes.data(),&paclintelliclimaegysavepop, sizeof(PAIntFuncType));
                signals.emplace_back(paclintelliclimaegysavepopSignal);
                Signal paclmodesecriSignal;
                paclmodesecriSignal.signalId = (int32_t)PASignal::PA_CL_ModeSecRi;
                paclmodesecriSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclmodesecri;
                //成员赋值
                paclmodesecri.availability = ntohl(data.paclmodesecri.availability);
                paclmodesecri.data = ntohl(data.paclmodesecri.data);
                paclmodesecri.format = ntohl(data.paclmodesecri.format);
                paclmodesecri.status = ntohl(data.paclmodesecri.status);
                memcpy(paclmodesecriSignal.value.bytes.data(),&paclmodesecri, sizeof(PAIntFuncType));
                signals.emplace_back(paclmodesecriSignal);
                Signal paclfanlevelriSignal;
                paclfanlevelriSignal.signalId = (int32_t)PASignal::PA_CL_FanLevelRi;
                paclfanlevelriSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclfanlevelri;
                //成员赋值
                paclfanlevelri.availability = ntohl(data.paclfanlevelri.availability);
                paclfanlevelri.data = ntohl(data.paclfanlevelri.data);
                paclfanlevelri.format = ntohl(data.paclfanlevelri.format);
                paclfanlevelri.status = ntohl(data.paclfanlevelri.status);
                memcpy(paclfanlevelriSignal.value.bytes.data(),&paclfanlevelri, sizeof(PAIntFuncType));
                signals.emplace_back(paclfanlevelriSignal);
                Signal paclsecfanlevelriSignal;
                paclsecfanlevelriSignal.signalId = (int32_t)PASignal::PA_CL_SecFanLevelRi;
                paclsecfanlevelriSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclsecfanlevelri;
                //成员赋值
                paclsecfanlevelri.availability = ntohl(data.paclsecfanlevelri.availability);
                paclsecfanlevelri.data = ntohl(data.paclsecfanlevelri.data);
                paclsecfanlevelri.format = ntohl(data.paclsecfanlevelri.format);
                paclsecfanlevelri.status = ntohl(data.paclsecfanlevelri.status);
                memcpy(paclsecfanlevelriSignal.value.bytes.data(),&paclsecfanlevelri, sizeof(PAIntFuncType));
                signals.emplace_back(paclsecfanlevelriSignal);
                Signal paclautoriSignal;
                paclautoriSignal.signalId = (int32_t)PASignal::PA_CL_AutoRi;
                paclautoriSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclautori;
                //成员赋值
                paclautori.availability = ntohl(data.paclautori.availability);
                paclautori.data = ntohl(data.paclautori.data);
                paclautori.format = ntohl(data.paclautori.format);
                paclautori.status = ntohl(data.paclautori.status);
                memcpy(paclautoriSignal.value.bytes.data(),&paclautori, sizeof(PAIntFuncType));
                signals.emplace_back(paclautoriSignal);
                Signal paclsecautoswriSignal;
                paclsecautoswriSignal.signalId = (int32_t)PASignal::PA_CL_SecAutoSwRi;
                paclsecautoswriSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclsecautoswri;
                //成员赋值
                paclsecautoswri.availability = ntohl(data.paclsecautoswri.availability);
                paclsecautoswri.data = ntohl(data.paclsecautoswri.data);
                paclsecautoswri.format = ntohl(data.paclsecautoswri.format);
                paclsecautoswri.status = ntohl(data.paclsecautoswri.status);
                memcpy(paclsecautoswriSignal.value.bytes.data(),&paclsecautoswri, sizeof(PAIntFuncType));
                signals.emplace_back(paclsecautoswriSignal);
                Signal paclpasstempsyncSignal;
                paclpasstempsyncSignal.signalId = (int32_t)PASignal::PA_CL_PassTempSync;
                paclpasstempsyncSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclpasstempsync;
                //成员赋值
                paclpasstempsync.availability = ntohl(data.paclpasstempsync.availability);
                paclpasstempsync.data = ntohl(data.paclpasstempsync.data);
                paclpasstempsync.format = ntohl(data.paclpasstempsync.format);
                paclpasstempsync.status = ntohl(data.paclpasstempsync.status);
                memcpy(paclpasstempsyncSignal.value.bytes.data(),&paclpasstempsync, sizeof(PAIntFuncType));
                signals.emplace_back(paclpasstempsyncSignal);
                Signal paclclimsmartonoroffSignal;
                paclclimsmartonoroffSignal.signalId = (int32_t)PASignal::PA_CL_ClimSmartOnOrOff;
                paclclimsmartonoroffSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclclimsmartonoroff;
                //成员赋值
                paclclimsmartonoroff.availability = ntohl(data.paclclimsmartonoroff.availability);
                paclclimsmartonoroff.data = ntohl(data.paclclimsmartonoroff.data);
                paclclimsmartonoroff.format = ntohl(data.paclclimsmartonoroff.format);
                paclclimsmartonoroff.status = ntohl(data.paclclimsmartonoroff.status);
                memcpy(paclclimsmartonoroffSignal.value.bytes.data(),&paclclimsmartonoroff, sizeof(PAIntFuncType));
                signals.emplace_back(paclclimsmartonoroffSignal);
                Signal pacldrvrctrlswtSignal;
                pacldrvrctrlswtSignal.signalId = (int32_t)PASignal::PA_CL_DrvrCtrlSwt;
                pacldrvrctrlswtSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pacldrvrctrlswt;
                //成员赋值
                pacldrvrctrlswt.availability = ntohl(data.pacldrvrctrlswt.availability);
                pacldrvrctrlswt.data = ntohl(data.pacldrvrctrlswt.data);
                pacldrvrctrlswt.format = ntohl(data.pacldrvrctrlswt.format);
                pacldrvrctrlswt.status = ntohl(data.pacldrvrctrlswt.status);
                memcpy(pacldrvrctrlswtSignal.value.bytes.data(),&pacldrvrctrlswt, sizeof(PAIntFuncType));
                signals.emplace_back(pacldrvrctrlswtSignal);
                Signal paclpassctrlswtSignal;
                paclpassctrlswtSignal.signalId = (int32_t)PASignal::PA_CL_PassCtrlSwt;
                paclpassctrlswtSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclpassctrlswt;
                //成员赋值
                paclpassctrlswt.availability = ntohl(data.paclpassctrlswt.availability);
                paclpassctrlswt.data = ntohl(data.paclpassctrlswt.data);
                paclpassctrlswt.format = ntohl(data.paclpassctrlswt.format);
                paclpassctrlswt.status = ntohl(data.paclpassctrlswt.status);
                memcpy(paclpassctrlswtSignal.value.bytes.data(),&paclpassctrlswt, sizeof(PAIntFuncType));
                signals.emplace_back(paclpassctrlswtSignal);
                Signal paclintelligentlycleaninSignal;
                paclintelligentlycleaninSignal.signalId = (int32_t)PASignal::PA_CL_IntelligentlyCleanin;
                paclintelligentlycleaninSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paclintelligentlycleanin;
                //成员赋值
                paclintelligentlycleanin.availability = ntohl(data.paclintelligentlycleanin.availability);
                paclintelligentlycleanin.data = ntohl(data.paclintelligentlycleanin.data);
                paclintelligentlycleanin.format = ntohl(data.paclintelligentlycleanin.format);
                paclintelligentlycleanin.status = ntohl(data.paclintelligentlycleanin.status);
                memcpy(paclintelligentlycleaninSignal.value.bytes.data(),&paclintelligentlycleanin, sizeof(PAIntFuncType));
                signals.emplace_back(paclintelligentlycleaninSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_DIAGDID:{
                
                constexpr int structLen=(int)sizeof(OpDiagDID_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(31);
                OpDiagDID_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal pacsdmonitorenSignal;
                pacsdmonitorenSignal.signalId = (int32_t)PASignal::PA_CSD_MONITOR_EN;
                pacsdmonitorenSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pacsdmonitoren;
                //成员赋值
                pacsdmonitoren.availability = ntohl(data.pacsdmonitoren.availability);
                for(size_t i = 0;i<4;++i){
                    pacsdmonitoren.data[i] = data.pacsdmonitoren.data[i];
                }
                pacsdmonitoren.format = ntohl(data.pacsdmonitoren.format);
                pacsdmonitoren.status = ntohl(data.pacsdmonitoren.status);
                memcpy(pacsdmonitorenSignal.value.bytes.data(),&pacsdmonitoren, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pacsdmonitorenSignal);
                Signal papaswamvideoinSignal;
                papaswamvideoinSignal.signalId = (int32_t)PASignal::PA_PASWAM_Video_in;
                papaswamvideoinSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 papaswamvideoin;
                //成员赋值
                papaswamvideoin.availability = ntohl(data.papaswamvideoin.availability);
                for(size_t i = 0;i<4;++i){
                    papaswamvideoin.data[i] = data.papaswamvideoin.data[i];
                }
                papaswamvideoin.format = ntohl(data.papaswamvideoin.format);
                papaswamvideoin.status = ntohl(data.papaswamvideoin.status);
                memcpy(papaswamvideoinSignal.value.bytes.data(),&papaswamvideoin, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(papaswamvideoinSignal);
                Signal padvrvideoinSignal;
                padvrvideoinSignal.signalId = (int32_t)PASignal::PA_DVR_Video_IN;
                padvrvideoinSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 padvrvideoin;
                //成员赋值
                padvrvideoin.availability = ntohl(data.padvrvideoin.availability);
                for(size_t i = 0;i<4;++i){
                    padvrvideoin.data[i] = data.padvrvideoin.data[i];
                }
                padvrvideoin.format = ntohl(data.padvrvideoin.format);
                padvrvideoin.status = ntohl(data.padvrvideoin.status);
                memcpy(padvrvideoinSignal.value.bytes.data(),&padvrvideoin, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(padvrvideoinSignal);
                Signal pagesturevideoinSignal;
                pagesturevideoinSignal.signalId = (int32_t)PASignal::PA_Gesture_Video_IN;
                pagesturevideoinSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pagesturevideoin;
                //成员赋值
                pagesturevideoin.availability = ntohl(data.pagesturevideoin.availability);
                for(size_t i = 0;i<4;++i){
                    pagesturevideoin.data[i] = data.pagesturevideoin.data[i];
                }
                pagesturevideoin.format = ntohl(data.pagesturevideoin.format);
                pagesturevideoin.status = ntohl(data.pagesturevideoin.status);
                memcpy(pagesturevideoinSignal.value.bytes.data(),&pagesturevideoin, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pagesturevideoinSignal);
                Signal pachatvideoinSignal;
                pachatvideoinSignal.signalId = (int32_t)PASignal::PA_Chat_Video_IN;
                pachatvideoinSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pachatvideoin;
                //成员赋值
                pachatvideoin.availability = ntohl(data.pachatvideoin.availability);
                for(size_t i = 0;i<4;++i){
                    pachatvideoin.data[i] = data.pachatvideoin.data[i];
                }
                pachatvideoin.format = ntohl(data.pachatvideoin.format);
                pachatvideoin.status = ntohl(data.pachatvideoin.status);
                memcpy(pachatvideoinSignal.value.bytes.data(),&pachatvideoin, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pachatvideoinSignal);
                Signal padcmd912psdmonitorenSignal;
                padcmd912psdmonitorenSignal.signalId = (int32_t)PASignal::PA_Dcm_D912_PSD_MONITOR_EN;
                padcmd912psdmonitorenSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 padcmd912psdmonitoren;
                //成员赋值
                padcmd912psdmonitoren.availability = ntohl(data.padcmd912psdmonitoren.availability);
                for(size_t i = 0;i<4;++i){
                    padcmd912psdmonitoren.data[i] = data.padcmd912psdmonitoren.data[i];
                }
                padcmd912psdmonitoren.format = ntohl(data.padcmd912psdmonitoren.format);
                padcmd912psdmonitoren.status = ntohl(data.padcmd912psdmonitoren.status);
                memcpy(padcmd912psdmonitorenSignal.value.bytes.data(),&padcmd912psdmonitoren, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(padcmd912psdmonitorenSignal);
                Signal pad94edhuloggingandlogfilesSignal;
                pad94edhuloggingandlogfilesSignal.signalId = (int32_t)PASignal::PA_D94E_DHU_logging_and_log_files;
                pad94edhuloggingandlogfilesSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pad94edhuloggingandlogfiles;
                //成员赋值
                pad94edhuloggingandlogfiles.availability = ntohl(data.pad94edhuloggingandlogfiles.availability);
                for(size_t i = 0;i<4;++i){
                    pad94edhuloggingandlogfiles.data[i] = data.pad94edhuloggingandlogfiles.data[i];
                }
                pad94edhuloggingandlogfiles.format = ntohl(data.pad94edhuloggingandlogfiles.format);
                pad94edhuloggingandlogfiles.status = ntohl(data.pad94edhuloggingandlogfiles.status);
                memcpy(pad94edhuloggingandlogfilesSignal.value.bytes.data(),&pad94edhuloggingandlogfiles, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pad94edhuloggingandlogfilesSignal);
                Signal paproductserialnumberSignal;
                paproductserialnumberSignal.signalId = (int32_t)PASignal::PA_Product_Serial_Number;
                paproductserialnumberSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 paproductserialnumber;
                //成员赋值
                paproductserialnumber.availability = ntohl(data.paproductserialnumber.availability);
                for(size_t i = 0;i<4;++i){
                    paproductserialnumber.data[i] = data.paproductserialnumber.data[i];
                }
                paproductserialnumber.format = ntohl(data.paproductserialnumber.format);
                paproductserialnumber.status = ntohl(data.paproductserialnumber.status);
                memcpy(paproductserialnumberSignal.value.bytes.data(),&paproductserialnumber, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(paproductserialnumberSignal);
                Signal paxdsnreadingSignal;
                paxdsnreadingSignal.signalId = (int32_t)PASignal::PA_XDSN_Reading;
                paxdsnreadingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType24),0);
                PAIntArrayFuncType24 paxdsnreading;
                //成员赋值
                paxdsnreading.availability = ntohl(data.paxdsnreading.availability);
                for(size_t i = 0;i<24;++i){
                    paxdsnreading.data[i] = data.paxdsnreading.data[i];
                }
                paxdsnreading.format = ntohl(data.paxdsnreading.format);
                paxdsnreading.status = ntohl(data.paxdsnreading.status);
                memcpy(paxdsnreadingSignal.value.bytes.data(),&paxdsnreading, sizeof(PAIntArrayFuncType24));
                signals.emplace_back(paxdsnreadingSignal);
                Signal paihuidreadingSignal;
                paihuidreadingSignal.signalId = (int32_t)PASignal::PA_IHUID_Reading;
                paihuidreadingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType24),0);
                PAIntArrayFuncType24 paihuidreading;
                //成员赋值
                paihuidreading.availability = ntohl(data.paihuidreading.availability);
                for(size_t i = 0;i<24;++i){
                    paihuidreading.data[i] = data.paihuidreading.data[i];
                }
                paihuidreading.format = ntohl(data.paihuidreading.format);
                paihuidreading.status = ntohl(data.paihuidreading.status);
                memcpy(paihuidreadingSignal.value.bytes.data(),&paihuidreading, sizeof(PAIntArrayFuncType24));
                signals.emplace_back(paihuidreadingSignal);
                Signal pahwversionreadingSignal;
                pahwversionreadingSignal.signalId = (int32_t)PASignal::PA_HW_Version_Reading;
                pahwversionreadingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType40),0);
                PAIntArrayFuncType40 pahwversionreading;
                //成员赋值
                pahwversionreading.availability = ntohl(data.pahwversionreading.availability);
                for(size_t i = 0;i<40;++i){
                    pahwversionreading.data[i] = data.pahwversionreading.data[i];
                }
                pahwversionreading.format = ntohl(data.pahwversionreading.format);
                pahwversionreading.status = ntohl(data.pahwversionreading.status);
                memcpy(pahwversionreadingSignal.value.bytes.data(),&pahwversionreading, sizeof(PAIntArrayFuncType40));
                signals.emplace_back(pahwversionreadingSignal);
                Signal pageelydeliveryassemblereadingSignal;
                pageelydeliveryassemblereadingSignal.signalId = (int32_t)PASignal::PA_Geely_Delivery_Assemble_Reading;
                pageelydeliveryassemblereadingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType8),0);
                PAIntArrayFuncType8 pageelydeliveryassemblereading;
                //成员赋值
                pageelydeliveryassemblereading.availability = ntohl(data.pageelydeliveryassemblereading.availability);
                for(size_t i = 0;i<8;++i){
                    pageelydeliveryassemblereading.data[i] = data.pageelydeliveryassemblereading.data[i];
                }
                pageelydeliveryassemblereading.format = ntohl(data.pageelydeliveryassemblereading.format);
                pageelydeliveryassemblereading.status = ntohl(data.pageelydeliveryassemblereading.status);
                memcpy(pageelydeliveryassemblereadingSignal.value.bytes.data(),&pageelydeliveryassemblereading, sizeof(PAIntArrayFuncType8));
                signals.emplace_back(pageelydeliveryassemblereadingSignal);
                Signal pageelyhswdreadingSignal;
                pageelyhswdreadingSignal.signalId = (int32_t)PASignal::PA_GeelyHSWD_Reading;
                pageelyhswdreadingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType8),0);
                PAIntArrayFuncType8 pageelyhswdreading;
                //成员赋值
                pageelyhswdreading.availability = ntohl(data.pageelyhswdreading.availability);
                for(size_t i = 0;i<8;++i){
                    pageelyhswdreading.data[i] = data.pageelyhswdreading.data[i];
                }
                pageelyhswdreading.format = ntohl(data.pageelyhswdreading.format);
                pageelyhswdreading.status = ntohl(data.pageelyhswdreading.status);
                memcpy(pageelyhswdreadingSignal.value.bytes.data(),&pageelyhswdreading, sizeof(PAIntArrayFuncType8));
                signals.emplace_back(pageelyhswdreadingSignal);
                Signal pavolvodeliveryassemblereadingSignal;
                pavolvodeliveryassemblereadingSignal.signalId = (int32_t)PASignal::PA_VolvoDelivery_Assemble_Reading;
                pavolvodeliveryassemblereadingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType8),0);
                PAIntArrayFuncType8 pavolvodeliveryassemblereading;
                //成员赋值
                pavolvodeliveryassemblereading.availability = ntohl(data.pavolvodeliveryassemblereading.availability);
                for(size_t i = 0;i<8;++i){
                    pavolvodeliveryassemblereading.data[i] = data.pavolvodeliveryassemblereading.data[i];
                }
                pavolvodeliveryassemblereading.format = ntohl(data.pavolvodeliveryassemblereading.format);
                pavolvodeliveryassemblereading.status = ntohl(data.pavolvodeliveryassemblereading.status);
                memcpy(pavolvodeliveryassemblereadingSignal.value.bytes.data(),&pavolvodeliveryassemblereading, sizeof(PAIntArrayFuncType8));
                signals.emplace_back(pavolvodeliveryassemblereadingSignal);
                Signal pamanufacturingsignalSignal;
                pamanufacturingsignalSignal.signalId = (int32_t)PASignal::PA_Manufacturing_Signal;
                pamanufacturingsignalSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pamanufacturingsignal;
                //成员赋值
                pamanufacturingsignal.availability = ntohl(data.pamanufacturingsignal.availability);
                for(size_t i = 0;i<4;++i){
                    pamanufacturingsignal.data[i] = data.pamanufacturingsignal.data[i];
                }
                pamanufacturingsignal.format = ntohl(data.pamanufacturingsignal.format);
                pamanufacturingsignal.status = ntohl(data.pamanufacturingsignal.status);
                memcpy(pamanufacturingsignalSignal.value.bytes.data(),&pamanufacturingsignal, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pamanufacturingsignalSignal);
                Signal pad907Signal;
                pad907Signal.signalId = (int32_t)PASignal::PA_D907;
                pad907Signal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pad907;
                //成员赋值
                pad907.availability = ntohl(data.pad907.availability);
                for(size_t i = 0;i<4;++i){
                    pad907.data[i] = data.pad907.data[i];
                }
                pad907.format = ntohl(data.pad907.format);
                pad907.status = ntohl(data.pad907.status);
                memcpy(pad907Signal.value.bytes.data(),&pad907, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pad907Signal);
                Signal pacsdmpsdenSignal;
                pacsdmpsdenSignal.signalId = (int32_t)PASignal::PA_CSDM_PSD_EN;
                pacsdmpsdenSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pacsdmpsden;
                //成员赋值
                pacsdmpsden.availability = ntohl(data.pacsdmpsden.availability);
                for(size_t i = 0;i<4;++i){
                    pacsdmpsden.data[i] = data.pacsdmpsden.data[i];
                }
                pacsdmpsden.format = ntohl(data.pacsdmpsden.format);
                pacsdmpsden.status = ntohl(data.pacsdmpsden.status);
                memcpy(pacsdmpsdenSignal.value.bytes.data(),&pacsdmpsden, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pacsdmpsdenSignal);
                Signal pafd29controlaudioinputsourceSignal;
                pafd29controlaudioinputsourceSignal.signalId = (int32_t)PASignal::PA_FD29_Control_Audio_input_Source;
                pafd29controlaudioinputsourceSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd29controlaudioinputsource;
                //成员赋值
                pafd29controlaudioinputsource.availability = ntohl(data.pafd29controlaudioinputsource.availability);
                for(size_t i = 0;i<4;++i){
                    pafd29controlaudioinputsource.data[i] = data.pafd29controlaudioinputsource.data[i];
                }
                pafd29controlaudioinputsource.format = ntohl(data.pafd29controlaudioinputsource.format);
                pafd29controlaudioinputsource.status = ntohl(data.pafd29controlaudioinputsource.status);
                memcpy(pafd29controlaudioinputsourceSignal.value.bytes.data(),&pafd29controlaudioinputsource, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd29controlaudioinputsourceSignal);
                Signal pafd12audiosignalgenerationSignal;
                pafd12audiosignalgenerationSignal.signalId = (int32_t)PASignal::PA_FD12_Audio_Signal_generation;
                pafd12audiosignalgenerationSignal.value.bytes.resize(sizeof(PAIntArrayFuncType8),0);
                PAIntArrayFuncType8 pafd12audiosignalgeneration;
                //成员赋值
                pafd12audiosignalgeneration.availability = ntohl(data.pafd12audiosignalgeneration.availability);
                for(size_t i = 0;i<8;++i){
                    pafd12audiosignalgeneration.data[i] = data.pafd12audiosignalgeneration.data[i];
                }
                pafd12audiosignalgeneration.format = ntohl(data.pafd12audiosignalgeneration.format);
                pafd12audiosignalgeneration.status = ntohl(data.pafd12audiosignalgeneration.status);
                memcpy(pafd12audiosignalgenerationSignal.value.bytes.data(),&pafd12audiosignalgeneration, sizeof(PAIntArrayFuncType8));
                signals.emplace_back(pafd12audiosignalgenerationSignal);
                Signal pafd17displayoutputgenerationSignal;
                pafd17displayoutputgenerationSignal.signalId = (int32_t)PASignal::PA_FD17_Display_output_generation;
                pafd17displayoutputgenerationSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd17displayoutputgeneration;
                //成员赋值
                pafd17displayoutputgeneration.availability = ntohl(data.pafd17displayoutputgeneration.availability);
                for(size_t i = 0;i<4;++i){
                    pafd17displayoutputgeneration.data[i] = data.pafd17displayoutputgeneration.data[i];
                }
                pafd17displayoutputgeneration.format = ntohl(data.pafd17displayoutputgeneration.format);
                pafd17displayoutputgeneration.status = ntohl(data.pafd17displayoutputgeneration.status);
                memcpy(pafd17displayoutputgenerationSignal.value.bytes.data(),&pafd17displayoutputgeneration, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd17displayoutputgenerationSignal);
                Signal pafd18camerainputgenerationSignal;
                pafd18camerainputgenerationSignal.signalId = (int32_t)PASignal::PA_FD18_Camera_input_generation;
                pafd18camerainputgenerationSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd18camerainputgeneration;
                //成员赋值
                pafd18camerainputgeneration.availability = ntohl(data.pafd18camerainputgeneration.availability);
                for(size_t i = 0;i<4;++i){
                    pafd18camerainputgeneration.data[i] = data.pafd18camerainputgeneration.data[i];
                }
                pafd18camerainputgeneration.format = ntohl(data.pafd18camerainputgeneration.format);
                pafd18camerainputgeneration.status = ntohl(data.pafd18camerainputgeneration.status);
                memcpy(pafd18camerainputgenerationSignal.value.bytes.data(),&pafd18camerainputgeneration, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd18camerainputgenerationSignal);
                Signal pafd33audiotunersettingSignal;
                pafd33audiotunersettingSignal.signalId = (int32_t)PASignal::PA_FD33_Audio_tuner_setting;
                pafd33audiotunersettingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType8),0);
                PAIntArrayFuncType8 pafd33audiotunersetting;
                //成员赋值
                pafd33audiotunersetting.availability = ntohl(data.pafd33audiotunersetting.availability);
                for(size_t i = 0;i<8;++i){
                    pafd33audiotunersetting.data[i] = data.pafd33audiotunersetting.data[i];
                }
                pafd33audiotunersetting.format = ntohl(data.pafd33audiotunersetting.format);
                pafd33audiotunersetting.status = ntohl(data.pafd33audiotunersetting.status);
                memcpy(pafd33audiotunersettingSignal.value.bytes.data(),&pafd33audiotunersetting, sizeof(PAIntArrayFuncType8));
                signals.emplace_back(pafd33audiotunersettingSignal);
                Signal pafd23tunerautomaticsearchsettingSignal;
                pafd23tunerautomaticsearchsettingSignal.signalId = (int32_t)PASignal::PA_FD23_Tuner_Automatic_search_setting;
                pafd23tunerautomaticsearchsettingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType8),0);
                PAIntArrayFuncType8 pafd23tunerautomaticsearchsetting;
                //成员赋值
                pafd23tunerautomaticsearchsetting.availability = ntohl(data.pafd23tunerautomaticsearchsetting.availability);
                for(size_t i = 0;i<8;++i){
                    pafd23tunerautomaticsearchsetting.data[i] = data.pafd23tunerautomaticsearchsetting.data[i];
                }
                pafd23tunerautomaticsearchsetting.format = ntohl(data.pafd23tunerautomaticsearchsetting.format);
                pafd23tunerautomaticsearchsetting.status = ntohl(data.pafd23tunerautomaticsearchsetting.status);
                memcpy(pafd23tunerautomaticsearchsettingSignal.value.bytes.data(),&pafd23tunerautomaticsearchsetting, sizeof(PAIntArrayFuncType8));
                signals.emplace_back(pafd23tunerautomaticsearchsettingSignal);
                Signal pafd41usbcommunicationcontrolSignal;
                pafd41usbcommunicationcontrolSignal.signalId = (int32_t)PASignal::PA_FD41_USB_communication_control;
                pafd41usbcommunicationcontrolSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd41usbcommunicationcontrol;
                //成员赋值
                pafd41usbcommunicationcontrol.availability = ntohl(data.pafd41usbcommunicationcontrol.availability);
                for(size_t i = 0;i<4;++i){
                    pafd41usbcommunicationcontrol.data[i] = data.pafd41usbcommunicationcontrol.data[i];
                }
                pafd41usbcommunicationcontrol.format = ntohl(data.pafd41usbcommunicationcontrol.format);
                pafd41usbcommunicationcontrol.status = ntohl(data.pafd41usbcommunicationcontrol.status);
                memcpy(pafd41usbcommunicationcontrolSignal.value.bytes.data(),&pafd41usbcommunicationcontrol, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd41usbcommunicationcontrolSignal);
                Signal pafd85btfunctiononoffcontrolSignal;
                pafd85btfunctiononoffcontrolSignal.signalId = (int32_t)PASignal::PA_FD85_BT_function_On_Off_control;
                pafd85btfunctiononoffcontrolSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd85btfunctiononoffcontrol;
                //成员赋值
                pafd85btfunctiononoffcontrol.availability = ntohl(data.pafd85btfunctiononoffcontrol.availability);
                for(size_t i = 0;i<4;++i){
                    pafd85btfunctiononoffcontrol.data[i] = data.pafd85btfunctiononoffcontrol.data[i];
                }
                pafd85btfunctiononoffcontrol.format = ntohl(data.pafd85btfunctiononoffcontrol.format);
                pafd85btfunctiononoffcontrol.status = ntohl(data.pafd85btfunctiononoffcontrol.status);
                memcpy(pafd85btfunctiononoffcontrolSignal.value.bytes.data(),&pafd85btfunctiononoffcontrol, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd85btfunctiononoffcontrolSignal);
                Signal pafd86bluetoothdevicevisibilityswitchsettingSignal;
                pafd86bluetoothdevicevisibilityswitchsettingSignal.signalId = (int32_t)PASignal::PA_FD86_Bluetooth_device_visibility_switch_setting;
                pafd86bluetoothdevicevisibilityswitchsettingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd86bluetoothdevicevisibilityswitchsetting;
                //成员赋值
                pafd86bluetoothdevicevisibilityswitchsetting.availability = ntohl(data.pafd86bluetoothdevicevisibilityswitchsetting.availability);
                for(size_t i = 0;i<4;++i){
                    pafd86bluetoothdevicevisibilityswitchsetting.data[i] = data.pafd86bluetoothdevicevisibilityswitchsetting.data[i];
                }
                pafd86bluetoothdevicevisibilityswitchsetting.format = ntohl(data.pafd86bluetoothdevicevisibilityswitchsetting.format);
                pafd86bluetoothdevicevisibilityswitchsetting.status = ntohl(data.pafd86bluetoothdevicevisibilityswitchsetting.status);
                memcpy(pafd86bluetoothdevicevisibilityswitchsettingSignal.value.bytes.data(),&pafd86bluetoothdevicevisibilityswitchsetting, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd86bluetoothdevicevisibilityswitchsettingSignal);
                Signal pafd91wififunctiononoffcontrolSignal;
                pafd91wififunctiononoffcontrolSignal.signalId = (int32_t)PASignal::PA_FD91_WIFI_function_On_Off_control;
                pafd91wififunctiononoffcontrolSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd91wififunctiononoffcontrol;
                //成员赋值
                pafd91wififunctiononoffcontrol.availability = ntohl(data.pafd91wififunctiononoffcontrol.availability);
                for(size_t i = 0;i<4;++i){
                    pafd91wififunctiononoffcontrol.data[i] = data.pafd91wififunctiononoffcontrol.data[i];
                }
                pafd91wififunctiononoffcontrol.format = ntohl(data.pafd91wififunctiononoffcontrol.format);
                pafd91wififunctiononoffcontrol.status = ntohl(data.pafd91wififunctiononoffcontrol.status);
                memcpy(pafd91wififunctiononoffcontrolSignal.value.bytes.data(),&pafd91wififunctiononoffcontrol, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd91wififunctiononoffcontrolSignal);
                Signal pafd94bluetoothloopbackmodesettingSignal;
                pafd94bluetoothloopbackmodesettingSignal.signalId = (int32_t)PASignal::PA_FD94_Bluetooth_Loopback_Mode_setting;
                pafd94bluetoothloopbackmodesettingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd94bluetoothloopbackmodesetting;
                //成员赋值
                pafd94bluetoothloopbackmodesetting.availability = ntohl(data.pafd94bluetoothloopbackmodesetting.availability);
                for(size_t i = 0;i<4;++i){
                    pafd94bluetoothloopbackmodesetting.data[i] = data.pafd94bluetoothloopbackmodesetting.data[i];
                }
                pafd94bluetoothloopbackmodesetting.format = ntohl(data.pafd94bluetoothloopbackmodesetting.format);
                pafd94bluetoothloopbackmodesetting.status = ntohl(data.pafd94bluetoothloopbackmodesetting.status);
                memcpy(pafd94bluetoothloopbackmodesettingSignal.value.bytes.data(),&pafd94bluetoothloopbackmodesetting, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd94bluetoothloopbackmodesettingSignal);
                Signal pafd97wifimodesettingSignal;
                pafd97wifimodesettingSignal.signalId = (int32_t)PASignal::PA_FD97_WIFI_mode_setting;
                pafd97wifimodesettingSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd97wifimodesetting;
                //成员赋值
                pafd97wifimodesetting.availability = ntohl(data.pafd97wifimodesetting.availability);
                for(size_t i = 0;i<4;++i){
                    pafd97wifimodesetting.data[i] = data.pafd97wifimodesetting.data[i];
                }
                pafd97wifimodesetting.format = ntohl(data.pafd97wifimodesetting.format);
                pafd97wifimodesetting.status = ntohl(data.pafd97wifimodesetting.status);
                memcpy(pafd97wifimodesettingSignal.value.bytes.data(),&pafd97wifimodesetting, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd97wifimodesettingSignal);
                Signal pafd88adbswitchSignal;
                pafd88adbswitchSignal.signalId = (int32_t)PASignal::PA_FD88_ADB_Switch;
                pafd88adbswitchSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafd88adbswitch;
                //成员赋值
                pafd88adbswitch.availability = ntohl(data.pafd88adbswitch.availability);
                for(size_t i = 0;i<4;++i){
                    pafd88adbswitch.data[i] = data.pafd88adbswitch.data[i];
                }
                pafd88adbswitch.format = ntohl(data.pafd88adbswitch.format);
                pafd88adbswitch.status = ntohl(data.pafd88adbswitch.status);
                memcpy(pafd88adbswitchSignal.value.bytes.data(),&pafd88adbswitch, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafd88adbswitchSignal);
                Signal paf12aecucoreassemblypartnumberSignal;
                paf12aecucoreassemblypartnumberSignal.signalId = (int32_t)PASignal::PA_F12A_ECU_Core_Assembly_PartNumber;
                paf12aecucoreassemblypartnumberSignal.value.bytes.resize(sizeof(PAIntArrayFuncType8),0);
                PAIntArrayFuncType8 paf12aecucoreassemblypartnumber;
                //成员赋值
                paf12aecucoreassemblypartnumber.availability = ntohl(data.paf12aecucoreassemblypartnumber.availability);
                for(size_t i = 0;i<8;++i){
                    paf12aecucoreassemblypartnumber.data[i] = data.paf12aecucoreassemblypartnumber.data[i];
                }
                paf12aecucoreassemblypartnumber.format = ntohl(data.paf12aecucoreassemblypartnumber.format);
                paf12aecucoreassemblypartnumber.status = ntohl(data.paf12aecucoreassemblypartnumber.status);
                memcpy(paf12aecucoreassemblypartnumberSignal.value.bytes.data(),&paf12aecucoreassemblypartnumber, sizeof(PAIntArrayFuncType8));
                signals.emplace_back(paf12aecucoreassemblypartnumberSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_DIAGOTA:{
                
                constexpr int structLen=(int)sizeof(OpDiagOTA_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(3);
                OpDiagOTA_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal paotadisplayversiond0d0Signal;
                paotadisplayversiond0d0Signal.signalId = (int32_t)PASignal::PA_OTA_Display_version_D0D0;
                paotadisplayversiond0d0Signal.value.bytes.resize(sizeof(PAIntArrayFuncType64),0);
                PAIntArrayFuncType64 paotadisplayversiond0d0;
                //成员赋值
                paotadisplayversiond0d0.availability = ntohl(data.paotadisplayversiond0d0.availability);
                for(size_t i = 0;i<64;++i){
                    paotadisplayversiond0d0.data[i] = data.paotadisplayversiond0d0.data[i];
                }
                paotadisplayversiond0d0.format = ntohl(data.paotadisplayversiond0d0.format);
                paotadisplayversiond0d0.status = ntohl(data.paotadisplayversiond0d0.status);
                memcpy(paotadisplayversiond0d0Signal.value.bytes.data(),&paotadisplayversiond0d0, sizeof(PAIntArrayFuncType64));
                signals.emplace_back(paotadisplayversiond0d0Signal);
                Signal paotabaselineswstructureidentifierd0d1Signal;
                paotabaselineswstructureidentifierd0d1Signal.signalId = (int32_t)PASignal::PA_OTA_Baseline_SW_Structure_Identifier_D0D1;
                paotabaselineswstructureidentifierd0d1Signal.value.bytes.resize(sizeof(PAIntArrayFuncType48),0);
                PAIntArrayFuncType48 paotabaselineswstructureidentifierd0d1;
                //成员赋值
                paotabaselineswstructureidentifierd0d1.availability = ntohl(data.paotabaselineswstructureidentifierd0d1.availability);
                for(size_t i = 0;i<48;++i){
                    paotabaselineswstructureidentifierd0d1.data[i] = data.paotabaselineswstructureidentifierd0d1.data[i];
                }
                paotabaselineswstructureidentifierd0d1.format = ntohl(data.paotabaselineswstructureidentifierd0d1.format);
                paotabaselineswstructureidentifierd0d1.status = ntohl(data.paotabaselineswstructureidentifierd0d1.status);
                memcpy(paotabaselineswstructureidentifierd0d1Signal.value.bytes.data(),&paotabaselineswstructureidentifierd0d1, sizeof(PAIntArrayFuncType48));
                signals.emplace_back(paotabaselineswstructureidentifierd0d1Signal);
                Signal paotadescriptiond0d2Signal;
                paotadescriptiond0d2Signal.signalId = (int32_t)PASignal::PA_OTA_description_D0D2;
                paotadescriptiond0d2Signal.value.bytes.resize(sizeof(PAIntArrayFuncType1024),0);
                PAIntArrayFuncType1024 paotadescriptiond0d2;
                //成员赋值
                paotadescriptiond0d2.availability = ntohl(data.paotadescriptiond0d2.availability);
                for(size_t i = 0;i<1024;++i){
                    paotadescriptiond0d2.data[i] = data.paotadescriptiond0d2.data[i];
                }
                paotadescriptiond0d2.format = ntohl(data.paotadescriptiond0d2.format);
                paotadescriptiond0d2.status = ntohl(data.paotadescriptiond0d2.status);
                memcpy(paotadescriptiond0d2Signal.value.bytes.data(),&paotadescriptiond0d2, sizeof(PAIntArrayFuncType1024));
                signals.emplace_back(paotadescriptiond0d2Signal);
            }
            break;

            case EcarXSignalServiceID::serviceID_DIAGPROXY:{
                
                constexpr int structLen=(int)sizeof(OpDiagProxy_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(5);
                OpDiagProxy_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal padiagproxystatusSignal;
                padiagproxystatusSignal.signalId = (int32_t)PASignal::PA_DiagProxy_Status;
                padiagproxystatusSignal.value.bytes.resize(sizeof(PAIntArrayFuncType56),0);
                PAIntArrayFuncType56 padiagproxystatus;
                //成员赋值
                padiagproxystatus.availability = ntohl(data.padiagproxystatus.availability);
                for(size_t i = 0;i<56;++i){
                    padiagproxystatus.data[i] = data.padiagproxystatus.data[i];
                }
                padiagproxystatus.format = ntohl(data.padiagproxystatus.format);
                padiagproxystatus.status = ntohl(data.padiagproxystatus.status);
                memcpy(padiagproxystatusSignal.value.bytes.data(),&padiagproxystatus, sizeof(PAIntArrayFuncType56));
                signals.emplace_back(padiagproxystatusSignal);
                Signal padiagproxycsdgwphySignal;
                padiagproxycsdgwphySignal.signalId = (int32_t)PASignal::PA_DiagProxy_Csd_GW_Phy;
                padiagproxycsdgwphySignal.value.bytes.resize(sizeof(PAIntArrayFuncType40),0);
                PAIntArrayFuncType40 padiagproxycsdgwphy;
                //成员赋值
                padiagproxycsdgwphy.availability = ntohl(data.padiagproxycsdgwphy.availability);
                for(size_t i = 0;i<40;++i){
                    padiagproxycsdgwphy.data[i] = data.padiagproxycsdgwphy.data[i];
                }
                padiagproxycsdgwphy.format = ntohl(data.padiagproxycsdgwphy.format);
                padiagproxycsdgwphy.status = ntohl(data.padiagproxycsdgwphy.status);
                memcpy(padiagproxycsdgwphySignal.value.bytes.data(),&padiagproxycsdgwphy, sizeof(PAIntArrayFuncType40));
                signals.emplace_back(padiagproxycsdgwphySignal);
                Signal padiagproxycsdgwfunSignal;
                padiagproxycsdgwfunSignal.signalId = (int32_t)PASignal::PA_DiagProxy_Csd_GW_Fun;
                padiagproxycsdgwfunSignal.value.bytes.resize(sizeof(PAIntArrayFuncType40),0);
                PAIntArrayFuncType40 padiagproxycsdgwfun;
                //成员赋值
                padiagproxycsdgwfun.availability = ntohl(data.padiagproxycsdgwfun.availability);
                for(size_t i = 0;i<40;++i){
                    padiagproxycsdgwfun.data[i] = data.padiagproxycsdgwfun.data[i];
                }
                padiagproxycsdgwfun.format = ntohl(data.padiagproxycsdgwfun.format);
                padiagproxycsdgwfun.status = ntohl(data.padiagproxycsdgwfun.status);
                memcpy(padiagproxycsdgwfunSignal.value.bytes.data(),&padiagproxycsdgwfun, sizeof(PAIntArrayFuncType40));
                signals.emplace_back(padiagproxycsdgwfunSignal);
                Signal padiagproxycsdmgwphySignal;
                padiagproxycsdmgwphySignal.signalId = (int32_t)PASignal::PA_DiagProxy_Csdm_GW_Phy;
                padiagproxycsdmgwphySignal.value.bytes.resize(sizeof(PAIntArrayFuncType40),0);
                PAIntArrayFuncType40 padiagproxycsdmgwphy;
                //成员赋值
                padiagproxycsdmgwphy.availability = ntohl(data.padiagproxycsdmgwphy.availability);
                for(size_t i = 0;i<40;++i){
                    padiagproxycsdmgwphy.data[i] = data.padiagproxycsdmgwphy.data[i];
                }
                padiagproxycsdmgwphy.format = ntohl(data.padiagproxycsdmgwphy.format);
                padiagproxycsdmgwphy.status = ntohl(data.padiagproxycsdmgwphy.status);
                memcpy(padiagproxycsdmgwphySignal.value.bytes.data(),&padiagproxycsdmgwphy, sizeof(PAIntArrayFuncType40));
                signals.emplace_back(padiagproxycsdmgwphySignal);
                Signal padiagproxycsdmgwfunSignal;
                padiagproxycsdmgwfunSignal.signalId = (int32_t)PASignal::PA_DiagProxy_Csdm_GW_Fun;
                padiagproxycsdmgwfunSignal.value.bytes.resize(sizeof(PAIntArrayFuncType40),0);
                PAIntArrayFuncType40 padiagproxycsdmgwfun;
                //成员赋值
                padiagproxycsdmgwfun.availability = ntohl(data.padiagproxycsdmgwfun.availability);
                for(size_t i = 0;i<40;++i){
                    padiagproxycsdmgwfun.data[i] = data.padiagproxycsdmgwfun.data[i];
                }
                padiagproxycsdmgwfun.format = ntohl(data.padiagproxycsdmgwfun.format);
                padiagproxycsdmgwfun.status = ntohl(data.padiagproxycsdmgwfun.status);
                memcpy(padiagproxycsdmgwfunSignal.value.bytes.data(),&padiagproxycsdmgwfun, sizeof(PAIntArrayFuncType40));
                signals.emplace_back(padiagproxycsdmgwfunSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_DIAGVFC:{
                
                constexpr int structLen=(int)sizeof(OpDiagVFC_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpDiagVFC_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal pafefdsendvfcidSignal;
                pafefdsendvfcidSignal.signalId = (int32_t)PASignal::PA_FEFD_Send_VFC_Id;
                pafefdsendvfcidSignal.value.bytes.resize(sizeof(PAIntArrayFuncType4),0);
                PAIntArrayFuncType4 pafefdsendvfcid;
                //成员赋值
                pafefdsendvfcid.availability = ntohl(data.pafefdsendvfcid.availability);
                for(size_t i = 0;i<4;++i){
                    pafefdsendvfcid.data[i] = data.pafefdsendvfcid.data[i];
                }
                pafefdsendvfcid.format = ntohl(data.pafefdsendvfcid.format);
                pafefdsendvfcid.status = ntohl(data.pafefdsendvfcid.status);
                memcpy(pafefdsendvfcidSignal.value.bytes.data(),&pafefdsendvfcid, sizeof(PAIntArrayFuncType4));
                signals.emplace_back(pafefdsendvfcidSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_ECVERSION:{
                
                constexpr int structLen=(int)sizeof(OpECVersion_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpECVersion_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal paecversionSignal;
                paecversionSignal.signalId = (int32_t)PASignal::PA_EC_Version;
                paecversionSignal.value.bytes.resize(sizeof(PAStringFuncType32),0);
                PAStringFuncType32 paecversion;
                //成员赋值
                paecversion.availability = ntohl(data.paecversion.availability);
                for(size_t i = 0;i<32;++i){
                    paecversion.data[i] = data.paecversion.data[i];
                }
                paecversion.format = ntohl(data.paecversion.format);
                paecversion.status = ntohl(data.paecversion.status);
                memcpy(paecversionSignal.value.bytes.data(),&paecversion, sizeof(PAStringFuncType32));
                signals.emplace_back(paecversionSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_EXTAMPCTRL:{
                
                constexpr int structLen=(int)sizeof(OpExtAmpCtrl_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpExtAmpCtrl_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal paampdiagresultSignal;
                paampdiagresultSignal.signalId = (int32_t)PASignal::PA_AmpDiagResult;
                paampdiagresultSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paampdiagresult;
                //成员赋值
                paampdiagresult.availability = ntohl(data.paampdiagresult.availability);
                paampdiagresult.data = ntohl(data.paampdiagresult.data);
                paampdiagresult.format = ntohl(data.paampdiagresult.format);
                paampdiagresult.status = ntohl(data.paampdiagresult.status);
                memcpy(paampdiagresultSignal.value.bytes.data(),&paampdiagresult, sizeof(PAIntFuncType));
                signals.emplace_back(paampdiagresultSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_MCULOGPANIC:{
                
                constexpr int structLen=(int)sizeof(OpMcuLogPanic_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpMcuLogPanic_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
            }
            break;

            case EcarXSignalServiceID::serviceID_POWER:{
                
                constexpr int structLen=(int)sizeof(OpPower_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpPower_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal papowerresSignal;
                papowerresSignal.signalId = (int32_t)PASignal::PA_Power_Res;
                papowerresSignal.value.bytes.resize(sizeof(PwrctrlVptoapimpl),0);
                PwrctrlVptoapimpl papowerres;
                //成员赋值
                papowerres.csdStatus = ntohl(data.papowerres.csdStatus);
                papowerres.csdPlayWelcome = ntohl(data.papowerres.csdPlayWelcome);
                papowerres.csdKeepOnTouch = ntohl(data.papowerres.csdKeepOnTouch);
                papowerres.csdPwm = ntohl(data.papowerres.csdPwm);
                papowerres.psdPwm = ntohl(data.papowerres.psdPwm);
                papowerres.voltageLevel = ntohl(data.papowerres.voltageLevel);
                papowerres.im = ntohl(data.papowerres.im);
                papowerres.iplm = ntohl(data.papowerres.iplm);
                papowerres.reserve = ntohl(data.papowerres.reserve);
                memcpy(papowerresSignal.value.bytes.data(),&papowerres, sizeof(PwrctrlVptoapimpl));
                signals.emplace_back(papowerresSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_SERVICEREMINDER:{
                
                constexpr int structLen=(int)sizeof(OpServiceReminder_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpServiceReminder_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal pasrvtrigSignal;
                pasrvtrigSignal.signalId = (int32_t)PASignal::PA_srvTrig;
                pasrvtrigSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pasrvtrig;
                //成员赋值
                pasrvtrig.availability = ntohl(data.pasrvtrig.availability);
                pasrvtrig.data = ntohl(data.pasrvtrig.data);
                pasrvtrig.format = ntohl(data.pasrvtrig.format);
                pasrvtrig.status = ntohl(data.pasrvtrig.status);
                memcpy(pasrvtrigSignal.value.bytes.data(),&pasrvtrig, sizeof(PAIntFuncType));
                signals.emplace_back(pasrvtrigSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_SWCODOOFTRIPINFO:{
                
                constexpr int structLen=(int)sizeof(OpSwcOdoOfTripInfo_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(2);
                OpSwcOdoOfTripInfo_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal paadastripmileageSignal;
                paadastripmileageSignal.signalId = (int32_t)PASignal::PA_AdasTripMileage;
                paadastripmileageSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paadastripmileage;
                //成员赋值
                paadastripmileage.availability = ntohl(data.paadastripmileage.availability);
                paadastripmileage.data = ntohl(data.paadastripmileage.data);
                paadastripmileage.format = ntohl(data.paadastripmileage.format);
                paadastripmileage.status = ntohl(data.paadastripmileage.status);
                memcpy(paadastripmileageSignal.value.bytes.data(),&paadastripmileage, sizeof(PAIntFuncType));
                signals.emplace_back(paadastripmileageSignal);
                Signal paadastripdateSignal;
                paadastripdateSignal.signalId = (int32_t)PASignal::PA_AdasTripDate;
                paadastripdateSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType paadastripdate;
                //成员赋值
                paadastripdate.availability = ntohl(data.paadastripdate.availability);
                paadastripdate.data = ntohl(data.paadastripdate.data);
                paadastripdate.format = ntohl(data.paadastripdate.format);
                paadastripdate.status = ntohl(data.paadastripdate.status);
                memcpy(paadastripdateSignal.value.bytes.data(),&paadastripdate, sizeof(PAIntFuncType));
                signals.emplace_back(paadastripdateSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_VFCIPWAKEUP:{
                
                constexpr int structLen=(int)sizeof(OpVFCIPWakeup_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(70);
                OpVFCIPWakeup_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal pavfcipwakeupSignal;
                pavfcipwakeupSignal.signalId = (int32_t)PASignal::PA_VFC_IPWakeup;
                pavfcipwakeupSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcipwakeup;
                //成员赋值
                pavfcipwakeup.availability = ntohl(data.pavfcipwakeup.availability);
                pavfcipwakeup.data = ntohl(data.pavfcipwakeup.data);
                pavfcipwakeup.format = ntohl(data.pavfcipwakeup.format);
                pavfcipwakeup.status = ntohl(data.pavfcipwakeup.status);
                memcpy(pavfcipwakeupSignal.value.bytes.data(),&pavfcipwakeup, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcipwakeupSignal);
                Signal pavfcfaceidnforhmicenSignal;
                pavfcfaceidnforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_FaceIdnForHmiCen;
                pavfcfaceidnforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcfaceidnforhmicen;
                //成员赋值
                pavfcfaceidnforhmicen.availability = ntohl(data.pavfcfaceidnforhmicen.availability);
                pavfcfaceidnforhmicen.data = ntohl(data.pavfcfaceidnforhmicen.data);
                pavfcfaceidnforhmicen.format = ntohl(data.pavfcfaceidnforhmicen.format);
                pavfcfaceidnforhmicen.status = ntohl(data.pavfcfaceidnforhmicen.status);
                memcpy(pavfcfaceidnforhmicenSignal.value.bytes.data(),&pavfcfaceidnforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcfaceidnforhmicenSignal);
                Signal pavfctelephonemanagerSignal;
                pavfctelephonemanagerSignal.signalId = (int32_t)PASignal::PA_VFC_TelephoneManager;
                pavfctelephonemanagerSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfctelephonemanager;
                //成员赋值
                pavfctelephonemanager.availability = ntohl(data.pavfctelephonemanager.availability);
                pavfctelephonemanager.data = ntohl(data.pavfctelephonemanager.data);
                pavfctelephonemanager.format = ntohl(data.pavfctelephonemanager.format);
                pavfctelephonemanager.status = ntohl(data.pavfctelephonemanager.status);
                memcpy(pavfctelephonemanagerSignal.value.bytes.data(),&pavfctelephonemanager, sizeof(PAIntFuncType));
                signals.emplace_back(pavfctelephonemanagerSignal);
                Signal pavfcsetvehcenclkindcnandsetgSignal;
                pavfcsetvehcenclkindcnandsetgSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehCenClkIndcnAndSetg;
                pavfcsetvehcenclkindcnandsetgSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehcenclkindcnandsetg;
                //成员赋值
                pavfcsetvehcenclkindcnandsetg.availability = ntohl(data.pavfcsetvehcenclkindcnandsetg.availability);
                pavfcsetvehcenclkindcnandsetg.data = ntohl(data.pavfcsetvehcenclkindcnandsetg.data);
                pavfcsetvehcenclkindcnandsetg.format = ntohl(data.pavfcsetvehcenclkindcnandsetg.format);
                pavfcsetvehcenclkindcnandsetg.status = ntohl(data.pavfcsetvehcenclkindcnandsetg.status);
                memcpy(pavfcsetvehcenclkindcnandsetgSignal.value.bytes.data(),&pavfcsetvehcenclkindcnandsetg, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehcenclkindcnandsetgSignal);
                Signal pavfcsetvehprivatelockSignal;
                pavfcsetvehprivatelockSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehPrivateLock;
                pavfcsetvehprivatelockSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehprivatelock;
                //成员赋值
                pavfcsetvehprivatelock.availability = ntohl(data.pavfcsetvehprivatelock.availability);
                pavfcsetvehprivatelock.data = ntohl(data.pavfcsetvehprivatelock.data);
                pavfcsetvehprivatelock.format = ntohl(data.pavfcsetvehprivatelock.format);
                pavfcsetvehprivatelock.status = ntohl(data.pavfcsetvehprivatelock.status);
                memcpy(pavfcsetvehprivatelockSignal.value.bytes.data(),&pavfcsetvehprivatelock, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehprivatelockSignal);
                Signal pavfcsetvehapaSignal;
                pavfcsetvehapaSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehApa;
                pavfcsetvehapaSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehapa;
                //成员赋值
                pavfcsetvehapa.availability = ntohl(data.pavfcsetvehapa.availability);
                pavfcsetvehapa.data = ntohl(data.pavfcsetvehapa.data);
                pavfcsetvehapa.format = ntohl(data.pavfcsetvehapa.format);
                pavfcsetvehapa.status = ntohl(data.pavfcsetvehapa.status);
                memcpy(pavfcsetvehapaSignal.value.bytes.data(),&pavfcsetvehapa, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehapaSignal);
                Signal pavfcsetvehavmSignal;
                pavfcsetvehavmSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehAvm;
                pavfcsetvehavmSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehavm;
                //成员赋值
                pavfcsetvehavm.availability = ntohl(data.pavfcsetvehavm.availability);
                pavfcsetvehavm.data = ntohl(data.pavfcsetvehavm.data);
                pavfcsetvehavm.format = ntohl(data.pavfcsetvehavm.format);
                pavfcsetvehavm.status = ntohl(data.pavfcsetvehavm.status);
                memcpy(pavfcsetvehavmSignal.value.bytes.data(),&pavfcsetvehavm, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehavmSignal);
                Signal pavfcsetvehtcamSignal;
                pavfcsetvehtcamSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehTcam;
                pavfcsetvehtcamSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehtcam;
                //成员赋值
                pavfcsetvehtcam.availability = ntohl(data.pavfcsetvehtcam.availability);
                pavfcsetvehtcam.data = ntohl(data.pavfcsetvehtcam.data);
                pavfcsetvehtcam.format = ntohl(data.pavfcsetvehtcam.format);
                pavfcsetvehtcam.status = ntohl(data.pavfcsetvehtcam.status);
                memcpy(pavfcsetvehtcamSignal.value.bytes.data(),&pavfcsetvehtcam, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehtcamSignal);
                Signal pavfcsetvehdvrSignal;
                pavfcsetvehdvrSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehDvr;
                pavfcsetvehdvrSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehdvr;
                //成员赋值
                pavfcsetvehdvr.availability = ntohl(data.pavfcsetvehdvr.availability);
                pavfcsetvehdvr.data = ntohl(data.pavfcsetvehdvr.data);
                pavfcsetvehdvr.format = ntohl(data.pavfcsetvehdvr.format);
                pavfcsetvehdvr.status = ntohl(data.pavfcsetvehdvr.status);
                memcpy(pavfcsetvehdvrSignal.value.bytes.data(),&pavfcsetvehdvr, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehdvrSignal);
                Signal pavfcvfcrsrv1Signal;
                pavfcvfcrsrv1Signal.signalId = (int32_t)PASignal::PA_VFC_VFCRsrv1;
                pavfcvfcrsrv1Signal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcvfcrsrv1;
                //成员赋值
                pavfcvfcrsrv1.availability = ntohl(data.pavfcvfcrsrv1.availability);
                pavfcvfcrsrv1.data = ntohl(data.pavfcvfcrsrv1.data);
                pavfcvfcrsrv1.format = ntohl(data.pavfcvfcrsrv1.format);
                pavfcvfcrsrv1.status = ntohl(data.pavfcvfcrsrv1.status);
                memcpy(pavfcvfcrsrv1Signal.value.bytes.data(),&pavfcvfcrsrv1, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcvfcrsrv1Signal);
                Signal pavfcvfcrsrv2Signal;
                pavfcvfcrsrv2Signal.signalId = (int32_t)PASignal::PA_VFC_VFCRsrv2;
                pavfcvfcrsrv2Signal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcvfcrsrv2;
                //成员赋值
                pavfcvfcrsrv2.availability = ntohl(data.pavfcvfcrsrv2.availability);
                pavfcvfcrsrv2.data = ntohl(data.pavfcvfcrsrv2.data);
                pavfcvfcrsrv2.format = ntohl(data.pavfcvfcrsrv2.format);
                pavfcvfcrsrv2.status = ntohl(data.pavfcvfcrsrv2.status);
                memcpy(pavfcvfcrsrv2Signal.value.bytes.data(),&pavfcvfcrsrv2, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcvfcrsrv2Signal);
                Signal pavfcvfcrsrv3Signal;
                pavfcvfcrsrv3Signal.signalId = (int32_t)PASignal::PA_VFC_VFCRsrv3;
                pavfcvfcrsrv3Signal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcvfcrsrv3;
                //成员赋值
                pavfcvfcrsrv3.availability = ntohl(data.pavfcvfcrsrv3.availability);
                pavfcvfcrsrv3.data = ntohl(data.pavfcvfcrsrv3.data);
                pavfcvfcrsrv3.format = ntohl(data.pavfcvfcrsrv3.format);
                pavfcvfcrsrv3.status = ntohl(data.pavfcvfcrsrv3.status);
                memcpy(pavfcvfcrsrv3Signal.value.bytes.data(),&pavfcvfcrsrv3, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcvfcrsrv3Signal);
                Signal pavfcvfcrsrv4Signal;
                pavfcvfcrsrv4Signal.signalId = (int32_t)PASignal::PA_VFC_VFCRsrv4;
                pavfcvfcrsrv4Signal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcvfcrsrv4;
                //成员赋值
                pavfcvfcrsrv4.availability = ntohl(data.pavfcvfcrsrv4.availability);
                pavfcvfcrsrv4.data = ntohl(data.pavfcvfcrsrv4.data);
                pavfcvfcrsrv4.format = ntohl(data.pavfcvfcrsrv4.format);
                pavfcvfcrsrv4.status = ntohl(data.pavfcvfcrsrv4.status);
                memcpy(pavfcvfcrsrv4Signal.value.bytes.data(),&pavfcvfcrsrv4, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcvfcrsrv4Signal);
                Signal pavfcvfcrsrv5Signal;
                pavfcvfcrsrv5Signal.signalId = (int32_t)PASignal::PA_VFC_VFCRsrv5;
                pavfcvfcrsrv5Signal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcvfcrsrv5;
                //成员赋值
                pavfcvfcrsrv5.availability = ntohl(data.pavfcvfcrsrv5.availability);
                pavfcvfcrsrv5.data = ntohl(data.pavfcvfcrsrv5.data);
                pavfcvfcrsrv5.format = ntohl(data.pavfcvfcrsrv5.format);
                pavfcvfcrsrv5.status = ntohl(data.pavfcvfcrsrv5.status);
                memcpy(pavfcvfcrsrv5Signal.value.bytes.data(),&pavfcvfcrsrv5, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcvfcrsrv5Signal);
                Signal pavfcsetvehfaceSignal;
                pavfcsetvehfaceSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehFace;
                pavfcsetvehfaceSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehface;
                //成员赋值
                pavfcsetvehface.availability = ntohl(data.pavfcsetvehface.availability);
                pavfcsetvehface.data = ntohl(data.pavfcsetvehface.data);
                pavfcsetvehface.format = ntohl(data.pavfcsetvehface.format);
                pavfcsetvehface.status = ntohl(data.pavfcsetvehface.status);
                memcpy(pavfcsetvehfaceSignal.value.bytes.data(),&pavfcsetvehface, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehfaceSignal);
                Signal pavfcvfcrebootSignal;
                pavfcvfcrebootSignal.signalId = (int32_t)PASignal::PA_VFC_VFC_Reboot;
                pavfcvfcrebootSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcvfcreboot;
                //成员赋值
                pavfcvfcreboot.availability = ntohl(data.pavfcvfcreboot.availability);
                pavfcvfcreboot.data = ntohl(data.pavfcvfcreboot.data);
                pavfcvfcreboot.format = ntohl(data.pavfcvfcreboot.format);
                pavfcvfcreboot.status = ntohl(data.pavfcvfcreboot.status);
                memcpy(pavfcvfcrebootSignal.value.bytes.data(),&pavfcvfcreboot, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcvfcrebootSignal);
                Signal pavfcfitnessmonitoringSignal;
                pavfcfitnessmonitoringSignal.signalId = (int32_t)PASignal::PA_VFC_FitnessMonitoring;
                pavfcfitnessmonitoringSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcfitnessmonitoring;
                //成员赋值
                pavfcfitnessmonitoring.availability = ntohl(data.pavfcfitnessmonitoring.availability);
                pavfcfitnessmonitoring.data = ntohl(data.pavfcfitnessmonitoring.data);
                pavfcfitnessmonitoring.format = ntohl(data.pavfcfitnessmonitoring.format);
                pavfcfitnessmonitoring.status = ntohl(data.pavfcfitnessmonitoring.status);
                memcpy(pavfcfitnessmonitoringSignal.value.bytes.data(),&pavfcfitnessmonitoring, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcfitnessmonitoringSignal);
                Signal pavfcexteriorlightshowSignal;
                pavfcexteriorlightshowSignal.signalId = (int32_t)PASignal::PA_VFC_ExteriorLightShow;
                pavfcexteriorlightshowSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcexteriorlightshow;
                //成员赋值
                pavfcexteriorlightshow.availability = ntohl(data.pavfcexteriorlightshow.availability);
                pavfcexteriorlightshow.data = ntohl(data.pavfcexteriorlightshow.data);
                pavfcexteriorlightshow.format = ntohl(data.pavfcexteriorlightshow.format);
                pavfcexteriorlightshow.status = ntohl(data.pavfcexteriorlightshow.status);
                memcpy(pavfcexteriorlightshowSignal.value.bytes.data(),&pavfcexteriorlightshow, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcexteriorlightshowSignal);
                Signal pavfcvehsurrndgsvisnSignal;
                pavfcvehsurrndgsvisnSignal.signalId = (int32_t)PASignal::PA_VFC_VehSurrndgsVisn;
                pavfcvehsurrndgsvisnSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcvehsurrndgsvisn;
                //成员赋值
                pavfcvehsurrndgsvisn.availability = ntohl(data.pavfcvehsurrndgsvisn.availability);
                pavfcvehsurrndgsvisn.data = ntohl(data.pavfcvehsurrndgsvisn.data);
                pavfcvehsurrndgsvisn.format = ntohl(data.pavfcvehsurrndgsvisn.format);
                pavfcvehsurrndgsvisn.status = ntohl(data.pavfcvehsurrndgsvisn.status);
                memcpy(pavfcvehsurrndgsvisnSignal.value.bytes.data(),&pavfcvehsurrndgsvisn, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcvehsurrndgsvisnSignal);
                Signal pavfcnavigationinfosharingSignal;
                pavfcnavigationinfosharingSignal.signalId = (int32_t)PASignal::PA_VFC_NavigationInfoSharing;
                pavfcnavigationinfosharingSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcnavigationinfosharing;
                //成员赋值
                pavfcnavigationinfosharing.availability = ntohl(data.pavfcnavigationinfosharing.availability);
                pavfcnavigationinfosharing.data = ntohl(data.pavfcnavigationinfosharing.data);
                pavfcnavigationinfosharing.format = ntohl(data.pavfcnavigationinfosharing.format);
                pavfcnavigationinfosharing.status = ntohl(data.pavfcnavigationinfosharing.status);
                memcpy(pavfcnavigationinfosharingSignal.value.bytes.data(),&pavfcnavigationinfosharing, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcnavigationinfosharingSignal);
                Signal pavfcscenemodeSignal;
                pavfcscenemodeSignal.signalId = (int32_t)PASignal::PA_VFC_SceneMode;
                pavfcscenemodeSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcscenemode;
                //成员赋值
                pavfcscenemode.availability = ntohl(data.pavfcscenemode.availability);
                pavfcscenemode.data = ntohl(data.pavfcscenemode.data);
                pavfcscenemode.format = ntohl(data.pavfcscenemode.format);
                pavfcscenemode.status = ntohl(data.pavfcscenemode.status);
                memcpy(pavfcscenemodeSignal.value.bytes.data(),&pavfcscenemode, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcscenemodeSignal);
                Signal pavfcstrangermodeforhmicenSignal;
                pavfcstrangermodeforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_StrangerModeForHmiCen;
                pavfcstrangermodeforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcstrangermodeforhmicen;
                //成员赋值
                pavfcstrangermodeforhmicen.availability = ntohl(data.pavfcstrangermodeforhmicen.availability);
                pavfcstrangermodeforhmicen.data = ntohl(data.pavfcstrangermodeforhmicen.data);
                pavfcstrangermodeforhmicen.format = ntohl(data.pavfcstrangermodeforhmicen.format);
                pavfcstrangermodeforhmicen.status = ntohl(data.pavfcstrangermodeforhmicen.status);
                memcpy(pavfcstrangermodeforhmicenSignal.value.bytes.data(),&pavfcstrangermodeforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcstrangermodeforhmicenSignal);
                Signal pavfcscenepetmodeforhmicenSignal;
                pavfcscenepetmodeforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_ScenePetModeForHmiCen;
                pavfcscenepetmodeforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcscenepetmodeforhmicen;
                //成员赋值
                pavfcscenepetmodeforhmicen.availability = ntohl(data.pavfcscenepetmodeforhmicen.availability);
                pavfcscenepetmodeforhmicen.data = ntohl(data.pavfcscenepetmodeforhmicen.data);
                pavfcscenepetmodeforhmicen.format = ntohl(data.pavfcscenepetmodeforhmicen.format);
                pavfcscenepetmodeforhmicen.status = ntohl(data.pavfcscenepetmodeforhmicen.status);
                memcpy(pavfcscenepetmodeforhmicenSignal.value.bytes.data(),&pavfcscenepetmodeforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcscenepetmodeforhmicenSignal);
                Signal pavfcstrangermodeforhmicenipSignal;
                pavfcstrangermodeforhmicenipSignal.signalId = (int32_t)PASignal::PA_VFC_StrangerModeForHmiCenIP;
                pavfcstrangermodeforhmicenipSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcstrangermodeforhmicenip;
                //成员赋值
                pavfcstrangermodeforhmicenip.availability = ntohl(data.pavfcstrangermodeforhmicenip.availability);
                pavfcstrangermodeforhmicenip.data = ntohl(data.pavfcstrangermodeforhmicenip.data);
                pavfcstrangermodeforhmicenip.format = ntohl(data.pavfcstrangermodeforhmicenip.format);
                pavfcstrangermodeforhmicenip.status = ntohl(data.pavfcstrangermodeforhmicenip.status);
                memcpy(pavfcstrangermodeforhmicenipSignal.value.bytes.data(),&pavfcstrangermodeforhmicenip, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcstrangermodeforhmicenipSignal);
                Signal pavfcsecrowfaceidnforhmicenSignal;
                pavfcsecrowfaceidnforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_SecRowFaceIdnForHmiCen;
                pavfcsecrowfaceidnforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsecrowfaceidnforhmicen;
                //成员赋值
                pavfcsecrowfaceidnforhmicen.availability = ntohl(data.pavfcsecrowfaceidnforhmicen.availability);
                pavfcsecrowfaceidnforhmicen.data = ntohl(data.pavfcsecrowfaceidnforhmicen.data);
                pavfcsecrowfaceidnforhmicen.format = ntohl(data.pavfcsecrowfaceidnforhmicen.format);
                pavfcsecrowfaceidnforhmicen.status = ntohl(data.pavfcsecrowfaceidnforhmicen.status);
                memcpy(pavfcsecrowfaceidnforhmicenSignal.value.bytes.data(),&pavfcsecrowfaceidnforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsecrowfaceidnforhmicenSignal);
                Signal pavfcscenebiochalmodeforhmicenSignal;
                pavfcscenebiochalmodeforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_SceneBiochalModeForHmiCen;
                pavfcscenebiochalmodeforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcscenebiochalmodeforhmicen;
                //成员赋值
                pavfcscenebiochalmodeforhmicen.availability = ntohl(data.pavfcscenebiochalmodeforhmicen.availability);
                pavfcscenebiochalmodeforhmicen.data = ntohl(data.pavfcscenebiochalmodeforhmicen.data);
                pavfcscenebiochalmodeforhmicen.format = ntohl(data.pavfcscenebiochalmodeforhmicen.format);
                pavfcscenebiochalmodeforhmicen.status = ntohl(data.pavfcscenebiochalmodeforhmicen.status);
                memcpy(pavfcscenebiochalmodeforhmicenSignal.value.bytes.data(),&pavfcscenebiochalmodeforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcscenebiochalmodeforhmicenSignal);
                Signal pavfcspeechctrlforhmicenSignal;
                pavfcspeechctrlforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_SpeechCtrlForHmiCen;
                pavfcspeechctrlforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcspeechctrlforhmicen;
                //成员赋值
                pavfcspeechctrlforhmicen.availability = ntohl(data.pavfcspeechctrlforhmicen.availability);
                pavfcspeechctrlforhmicen.data = ntohl(data.pavfcspeechctrlforhmicen.data);
                pavfcspeechctrlforhmicen.format = ntohl(data.pavfcspeechctrlforhmicen.format);
                pavfcspeechctrlforhmicen.status = ntohl(data.pavfcspeechctrlforhmicen.status);
                memcpy(pavfcspeechctrlforhmicenSignal.value.bytes.data(),&pavfcspeechctrlforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcspeechctrlforhmicenSignal);
                Signal pavfcsecfaceidnsummgrSignal;
                pavfcsecfaceidnsummgrSignal.signalId = (int32_t)PASignal::PA_VFC_SecFaceIdnSumMgr;
                pavfcsecfaceidnsummgrSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsecfaceidnsummgr;
                //成员赋值
                pavfcsecfaceidnsummgr.availability = ntohl(data.pavfcsecfaceidnsummgr.availability);
                pavfcsecfaceidnsummgr.data = ntohl(data.pavfcsecfaceidnsummgr.data);
                pavfcsecfaceidnsummgr.format = ntohl(data.pavfcsecfaceidnsummgr.format);
                pavfcsecfaceidnsummgr.status = ntohl(data.pavfcsecfaceidnsummgr.status);
                memcpy(pavfcsecfaceidnsummgrSignal.value.bytes.data(),&pavfcsecfaceidnsummgr, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsecfaceidnsummgrSignal);
                Signal pavfcscenecarwashmodeforhmicenSignal;
                pavfcscenecarwashmodeforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_SceneCarWashModeForHmiCen;
                pavfcscenecarwashmodeforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcscenecarwashmodeforhmicen;
                //成员赋值
                pavfcscenecarwashmodeforhmicen.availability = ntohl(data.pavfcscenecarwashmodeforhmicen.availability);
                pavfcscenecarwashmodeforhmicen.data = ntohl(data.pavfcscenecarwashmodeforhmicen.data);
                pavfcscenecarwashmodeforhmicen.format = ntohl(data.pavfcscenecarwashmodeforhmicen.format);
                pavfcscenecarwashmodeforhmicen.status = ntohl(data.pavfcscenecarwashmodeforhmicen.status);
                memcpy(pavfcscenecarwashmodeforhmicenSignal.value.bytes.data(),&pavfcscenecarwashmodeforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcscenecarwashmodeforhmicenSignal);
                Signal pavfcpintodrvforhmicenSignal;
                pavfcpintodrvforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_PinToDrvForHmiCen;
                pavfcpintodrvforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcpintodrvforhmicen;
                //成员赋值
                pavfcpintodrvforhmicen.availability = ntohl(data.pavfcpintodrvforhmicen.availability);
                pavfcpintodrvforhmicen.data = ntohl(data.pavfcpintodrvforhmicen.data);
                pavfcpintodrvforhmicen.format = ntohl(data.pavfcpintodrvforhmicen.format);
                pavfcpintodrvforhmicen.status = ntohl(data.pavfcpintodrvforhmicen.status);
                memcpy(pavfcpintodrvforhmicenSignal.value.bytes.data(),&pavfcpintodrvforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcpintodrvforhmicenSignal);
                Signal pavfcexteriorlightshowwinSignal;
                pavfcexteriorlightshowwinSignal.signalId = (int32_t)PASignal::PA_VFC_ExteriorLightShowWin;
                pavfcexteriorlightshowwinSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcexteriorlightshowwin;
                //成员赋值
                pavfcexteriorlightshowwin.availability = ntohl(data.pavfcexteriorlightshowwin.availability);
                pavfcexteriorlightshowwin.data = ntohl(data.pavfcexteriorlightshowwin.data);
                pavfcexteriorlightshowwin.format = ntohl(data.pavfcexteriorlightshowwin.format);
                pavfcexteriorlightshowwin.status = ntohl(data.pavfcexteriorlightshowwin.status);
                memcpy(pavfcexteriorlightshowwinSignal.value.bytes.data(),&pavfcexteriorlightshowwin, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcexteriorlightshowwinSignal);
                Signal pavfcgenchasettingsforhmicenipSignal;
                pavfcgenchasettingsforhmicenipSignal.signalId = (int32_t)PASignal::PA_VFC_GenChaSettingsForHmiCenIP;
                pavfcgenchasettingsforhmicenipSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcgenchasettingsforhmicenip;
                //成员赋值
                pavfcgenchasettingsforhmicenip.availability = ntohl(data.pavfcgenchasettingsforhmicenip.availability);
                pavfcgenchasettingsforhmicenip.data = ntohl(data.pavfcgenchasettingsforhmicenip.data);
                pavfcgenchasettingsforhmicenip.format = ntohl(data.pavfcgenchasettingsforhmicenip.format);
                pavfcgenchasettingsforhmicenip.status = ntohl(data.pavfcgenchasettingsforhmicenip.status);
                memcpy(pavfcgenchasettingsforhmicenipSignal.value.bytes.data(),&pavfcgenchasettingsforhmicenip, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcgenchasettingsforhmicenipSignal);
                Signal pavfcactvresplrmgripSignal;
                pavfcactvresplrmgripSignal.signalId = (int32_t)PASignal::PA_VFC_ActvReSplrMgrIP;
                pavfcactvresplrmgripSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcactvresplrmgrip;
                //成员赋值
                pavfcactvresplrmgrip.availability = ntohl(data.pavfcactvresplrmgrip.availability);
                pavfcactvresplrmgrip.data = ntohl(data.pavfcactvresplrmgrip.data);
                pavfcactvresplrmgrip.format = ntohl(data.pavfcactvresplrmgrip.format);
                pavfcactvresplrmgrip.status = ntohl(data.pavfcactvresplrmgrip.status);
                memcpy(pavfcactvresplrmgripSignal.value.bytes.data(),&pavfcactvresplrmgrip, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcactvresplrmgripSignal);
                Signal pavfcsuspctrlforhmicenipSignal;
                pavfcsuspctrlforhmicenipSignal.signalId = (int32_t)PASignal::PA_VFC_SuspCtrlForHmiCenIP;
                pavfcsuspctrlforhmicenipSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsuspctrlforhmicenip;
                //成员赋值
                pavfcsuspctrlforhmicenip.availability = ntohl(data.pavfcsuspctrlforhmicenip.availability);
                pavfcsuspctrlforhmicenip.data = ntohl(data.pavfcsuspctrlforhmicenip.data);
                pavfcsuspctrlforhmicenip.format = ntohl(data.pavfcsuspctrlforhmicenip.format);
                pavfcsuspctrlforhmicenip.status = ntohl(data.pavfcsuspctrlforhmicenip.status);
                memcpy(pavfcsuspctrlforhmicenipSignal.value.bytes.data(),&pavfcsuspctrlforhmicenip, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsuspctrlforhmicenipSignal);
                Signal pavfcseatcomfortfunctionsSignal;
                pavfcseatcomfortfunctionsSignal.signalId = (int32_t)PASignal::PA_VFC_SeatComfortFunctions;
                pavfcseatcomfortfunctionsSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcseatcomfortfunctions;
                //成员赋值
                pavfcseatcomfortfunctions.availability = ntohl(data.pavfcseatcomfortfunctions.availability);
                pavfcseatcomfortfunctions.data = ntohl(data.pavfcseatcomfortfunctions.data);
                pavfcseatcomfortfunctions.format = ntohl(data.pavfcseatcomfortfunctions.format);
                pavfcseatcomfortfunctions.status = ntohl(data.pavfcseatcomfortfunctions.status);
                memcpy(pavfcseatcomfortfunctionsSignal.value.bytes.data(),&pavfcseatcomfortfunctions, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcseatcomfortfunctionsSignal);
                Signal pavfcmirrctrlforhmicenSignal;
                pavfcmirrctrlforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_MirrCtrlForHmiCen;
                pavfcmirrctrlforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcmirrctrlforhmicen;
                //成员赋值
                pavfcmirrctrlforhmicen.availability = ntohl(data.pavfcmirrctrlforhmicen.availability);
                pavfcmirrctrlforhmicen.data = ntohl(data.pavfcmirrctrlforhmicen.data);
                pavfcmirrctrlforhmicen.format = ntohl(data.pavfcmirrctrlforhmicen.format);
                pavfcmirrctrlforhmicen.status = ntohl(data.pavfcmirrctrlforhmicen.status);
                memcpy(pavfcmirrctrlforhmicenSignal.value.bytes.data(),&pavfcmirrctrlforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcmirrctrlforhmicenSignal);
                Signal pavfcmirrctrlforhmicen3sSignal;
                pavfcmirrctrlforhmicen3sSignal.signalId = (int32_t)PASignal::PA_VFC_MirrCtrlForHmiCen_3s;
                pavfcmirrctrlforhmicen3sSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcmirrctrlforhmicen3s;
                //成员赋值
                pavfcmirrctrlforhmicen3s.availability = ntohl(data.pavfcmirrctrlforhmicen3s.availability);
                pavfcmirrctrlforhmicen3s.data = ntohl(data.pavfcmirrctrlforhmicen3s.data);
                pavfcmirrctrlforhmicen3s.format = ntohl(data.pavfcmirrctrlforhmicen3s.format);
                pavfcmirrctrlforhmicen3s.status = ntohl(data.pavfcmirrctrlforhmicen3s.status);
                memcpy(pavfcmirrctrlforhmicen3sSignal.value.bytes.data(),&pavfcmirrctrlforhmicen3s, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcmirrctrlforhmicen3sSignal);
                Signal pavfcmirrctrlforhmicen10sSignal;
                pavfcmirrctrlforhmicen10sSignal.signalId = (int32_t)PASignal::PA_VFC_MirrCtrlForHmiCen_10s;
                pavfcmirrctrlforhmicen10sSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcmirrctrlforhmicen10s;
                //成员赋值
                pavfcmirrctrlforhmicen10s.availability = ntohl(data.pavfcmirrctrlforhmicen10s.availability);
                pavfcmirrctrlforhmicen10s.data = ntohl(data.pavfcmirrctrlforhmicen10s.data);
                pavfcmirrctrlforhmicen10s.format = ntohl(data.pavfcmirrctrlforhmicen10s.format);
                pavfcmirrctrlforhmicen10s.status = ntohl(data.pavfcmirrctrlforhmicen10s.status);
                memcpy(pavfcmirrctrlforhmicen10sSignal.value.bytes.data(),&pavfcmirrctrlforhmicen10s, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcmirrctrlforhmicen10sSignal);
                Signal pavfcdimwinmgrwinSignal;
                pavfcdimwinmgrwinSignal.signalId = (int32_t)PASignal::PA_VFC_DimWinMgrWin;
                pavfcdimwinmgrwinSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcdimwinmgrwin;
                //成员赋值
                pavfcdimwinmgrwin.availability = ntohl(data.pavfcdimwinmgrwin.availability);
                pavfcdimwinmgrwin.data = ntohl(data.pavfcdimwinmgrwin.data);
                pavfcdimwinmgrwin.format = ntohl(data.pavfcdimwinmgrwin.format);
                pavfcdimwinmgrwin.status = ntohl(data.pavfcdimwinmgrwin.status);
                memcpy(pavfcdimwinmgrwinSignal.value.bytes.data(),&pavfcdimwinmgrwin, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcdimwinmgrwinSignal);
                Signal pavfcweatherSignal;
                pavfcweatherSignal.signalId = (int32_t)PASignal::PA_VFC_Weather;
                pavfcweatherSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcweather;
                //成员赋值
                pavfcweather.availability = ntohl(data.pavfcweather.availability);
                pavfcweather.data = ntohl(data.pavfcweather.data);
                pavfcweather.format = ntohl(data.pavfcweather.format);
                pavfcweather.status = ntohl(data.pavfcweather.status);
                memcpy(pavfcweatherSignal.value.bytes.data(),&pavfcweather, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcweatherSignal);
                Signal pavfcinterlightshowSignal;
                pavfcinterlightshowSignal.signalId = (int32_t)PASignal::PA_VFC_InterLightShow;
                pavfcinterlightshowSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcinterlightshow;
                //成员赋值
                pavfcinterlightshow.availability = ntohl(data.pavfcinterlightshow.availability);
                pavfcinterlightshow.data = ntohl(data.pavfcinterlightshow.data);
                pavfcinterlightshow.format = ntohl(data.pavfcinterlightshow.format);
                pavfcinterlightshow.status = ntohl(data.pavfcinterlightshow.status);
                memcpy(pavfcinterlightshowSignal.value.bytes.data(),&pavfcinterlightshow, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcinterlightshowSignal);
                Signal pavfcsetvehseatctrlforhmicenSignal;
                pavfcsetvehseatctrlforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehSeatCtrlForHmiCen;
                pavfcsetvehseatctrlforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehseatctrlforhmicen;
                //成员赋值
                pavfcsetvehseatctrlforhmicen.availability = ntohl(data.pavfcsetvehseatctrlforhmicen.availability);
                pavfcsetvehseatctrlforhmicen.data = ntohl(data.pavfcsetvehseatctrlforhmicen.data);
                pavfcsetvehseatctrlforhmicen.format = ntohl(data.pavfcsetvehseatctrlforhmicen.format);
                pavfcsetvehseatctrlforhmicen.status = ntohl(data.pavfcsetvehseatctrlforhmicen.status);
                memcpy(pavfcsetvehseatctrlforhmicenSignal.value.bytes.data(),&pavfcsetvehseatctrlforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehseatctrlforhmicenSignal);
                Signal pavfcsetvehsystemSignal;
                pavfcsetvehsystemSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehSystem;
                pavfcsetvehsystemSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehsystem;
                //成员赋值
                pavfcsetvehsystem.availability = ntohl(data.pavfcsetvehsystem.availability);
                pavfcsetvehsystem.data = ntohl(data.pavfcsetvehsystem.data);
                pavfcsetvehsystem.format = ntohl(data.pavfcsetvehsystem.format);
                pavfcsetvehsystem.status = ntohl(data.pavfcsetvehsystem.status);
                memcpy(pavfcsetvehsystemSignal.value.bytes.data(),&pavfcsetvehsystem, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehsystemSignal);
                Signal pavfcsetvehintrlictrlforhmicenSignal;
                pavfcsetvehintrlictrlforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehIntrLiCtrlForHmiCen;
                pavfcsetvehintrlictrlforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehintrlictrlforhmicen;
                //成员赋值
                pavfcsetvehintrlictrlforhmicen.availability = ntohl(data.pavfcsetvehintrlictrlforhmicen.availability);
                pavfcsetvehintrlictrlforhmicen.data = ntohl(data.pavfcsetvehintrlictrlforhmicen.data);
                pavfcsetvehintrlictrlforhmicen.format = ntohl(data.pavfcsetvehintrlictrlforhmicen.format);
                pavfcsetvehintrlictrlforhmicen.status = ntohl(data.pavfcsetvehintrlictrlforhmicen.status);
                memcpy(pavfcsetvehintrlictrlforhmicenSignal.value.bytes.data(),&pavfcsetvehintrlictrlforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehintrlictrlforhmicenSignal);
                Signal pavfcsetvehcrtladasSignal;
                pavfcsetvehcrtladasSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehCrtlAdas;
                pavfcsetvehcrtladasSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehcrtladas;
                //成员赋值
                pavfcsetvehcrtladas.availability = ntohl(data.pavfcsetvehcrtladas.availability);
                pavfcsetvehcrtladas.data = ntohl(data.pavfcsetvehcrtladas.data);
                pavfcsetvehcrtladas.format = ntohl(data.pavfcsetvehcrtladas.format);
                pavfcsetvehcrtladas.status = ntohl(data.pavfcsetvehcrtladas.status);
                memcpy(pavfcsetvehcrtladasSignal.value.bytes.data(),&pavfcsetvehcrtladas, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehcrtladasSignal);
                Signal pavfcsetvehdrvmodeSignal;
                pavfcsetvehdrvmodeSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehDrvMode;
                pavfcsetvehdrvmodeSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehdrvmode;
                //成员赋值
                pavfcsetvehdrvmode.availability = ntohl(data.pavfcsetvehdrvmode.availability);
                pavfcsetvehdrvmode.data = ntohl(data.pavfcsetvehdrvmode.data);
                pavfcsetvehdrvmode.format = ntohl(data.pavfcsetvehdrvmode.format);
                pavfcsetvehdrvmode.status = ntohl(data.pavfcsetvehdrvmode.status);
                memcpy(pavfcsetvehdrvmodeSignal.value.bytes.data(),&pavfcsetvehdrvmode, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehdrvmodeSignal);
                Signal pavfcsetvehmiscSignal;
                pavfcsetvehmiscSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehMisc;
                pavfcsetvehmiscSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehmisc;
                //成员赋值
                pavfcsetvehmisc.availability = ntohl(data.pavfcsetvehmisc.availability);
                pavfcsetvehmisc.data = ntohl(data.pavfcsetvehmisc.data);
                pavfcsetvehmisc.format = ntohl(data.pavfcsetvehmisc.format);
                pavfcsetvehmisc.status = ntohl(data.pavfcsetvehmisc.status);
                memcpy(pavfcsetvehmiscSignal.value.bytes.data(),&pavfcsetvehmisc, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehmiscSignal);
                Signal pavfcsetvehchargingSignal;
                pavfcsetvehchargingSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehCharging;
                pavfcsetvehchargingSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehcharging;
                //成员赋值
                pavfcsetvehcharging.availability = ntohl(data.pavfcsetvehcharging.availability);
                pavfcsetvehcharging.data = ntohl(data.pavfcsetvehcharging.data);
                pavfcsetvehcharging.format = ntohl(data.pavfcsetvehcharging.format);
                pavfcsetvehcharging.status = ntohl(data.pavfcsetvehcharging.status);
                memcpy(pavfcsetvehchargingSignal.value.bytes.data(),&pavfcsetvehcharging, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehchargingSignal);
                Signal pavfcsetvehmobileequipwirelschrgSignal;
                pavfcsetvehmobileequipwirelschrgSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehMobileEquipWirelsChrg;
                pavfcsetvehmobileequipwirelschrgSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehmobileequipwirelschrg;
                //成员赋值
                pavfcsetvehmobileequipwirelschrg.availability = ntohl(data.pavfcsetvehmobileequipwirelschrg.availability);
                pavfcsetvehmobileequipwirelschrg.data = ntohl(data.pavfcsetvehmobileequipwirelschrg.data);
                pavfcsetvehmobileequipwirelschrg.format = ntohl(data.pavfcsetvehmobileequipwirelschrg.format);
                pavfcsetvehmobileequipwirelschrg.status = ntohl(data.pavfcsetvehmobileequipwirelschrg.status);
                memcpy(pavfcsetvehmobileequipwirelschrgSignal.value.bytes.data(),&pavfcsetvehmobileequipwirelschrg, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehmobileequipwirelschrgSignal);
                Signal pavfcsetvehsmallcycleSignal;
                pavfcsetvehsmallcycleSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehSmallCycle;
                pavfcsetvehsmallcycleSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehsmallcycle;
                //成员赋值
                pavfcsetvehsmallcycle.availability = ntohl(data.pavfcsetvehsmallcycle.availability);
                pavfcsetvehsmallcycle.data = ntohl(data.pavfcsetvehsmallcycle.data);
                pavfcsetvehsmallcycle.format = ntohl(data.pavfcsetvehsmallcycle.format);
                pavfcsetvehsmallcycle.status = ntohl(data.pavfcsetvehsmallcycle.status);
                memcpy(pavfcsetvehsmallcycleSignal.value.bytes.data(),&pavfcsetvehsmallcycle, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehsmallcycleSignal);
                Signal pavfcsetvehmmedbtniflsSignal;
                pavfcsetvehmmedbtniflsSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehMmedbtnifLS;
                pavfcsetvehmmedbtniflsSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehmmedbtnifls;
                //成员赋值
                pavfcsetvehmmedbtnifls.availability = ntohl(data.pavfcsetvehmmedbtnifls.availability);
                pavfcsetvehmmedbtnifls.data = ntohl(data.pavfcsetvehmmedbtnifls.data);
                pavfcsetvehmmedbtnifls.format = ntohl(data.pavfcsetvehmmedbtnifls.format);
                pavfcsetvehmmedbtnifls.status = ntohl(data.pavfcsetvehmmedbtnifls.status);
                memcpy(pavfcsetvehmmedbtniflsSignal.value.bytes.data(),&pavfcsetvehmmedbtnifls, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehmmedbtniflsSignal);
                Signal pavfcv2xctrlforhmicenSignal;
                pavfcv2xctrlforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_V2XCtrlForHmiCen;
                pavfcv2xctrlforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcv2xctrlforhmicen;
                //成员赋值
                pavfcv2xctrlforhmicen.availability = ntohl(data.pavfcv2xctrlforhmicen.availability);
                pavfcv2xctrlforhmicen.data = ntohl(data.pavfcv2xctrlforhmicen.data);
                pavfcv2xctrlforhmicen.format = ntohl(data.pavfcv2xctrlforhmicen.format);
                pavfcv2xctrlforhmicen.status = ntohl(data.pavfcv2xctrlforhmicen.status);
                memcpy(pavfcv2xctrlforhmicenSignal.value.bytes.data(),&pavfcv2xctrlforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcv2xctrlforhmicenSignal);
                Signal pavfcpwrdoorctrlforhmicenpcSignal;
                pavfcpwrdoorctrlforhmicenpcSignal.signalId = (int32_t)PASignal::PA_VFC_PwrDoorCtrlForHmiCenPC;
                pavfcpwrdoorctrlforhmicenpcSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcpwrdoorctrlforhmicenpc;
                //成员赋值
                pavfcpwrdoorctrlforhmicenpc.availability = ntohl(data.pavfcpwrdoorctrlforhmicenpc.availability);
                pavfcpwrdoorctrlforhmicenpc.data = ntohl(data.pavfcpwrdoorctrlforhmicenpc.data);
                pavfcpwrdoorctrlforhmicenpc.format = ntohl(data.pavfcpwrdoorctrlforhmicenpc.format);
                pavfcpwrdoorctrlforhmicenpc.status = ntohl(data.pavfcpwrdoorctrlforhmicenpc.status);
                memcpy(pavfcpwrdoorctrlforhmicenpcSignal.value.bytes.data(),&pavfcpwrdoorctrlforhmicenpc, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcpwrdoorctrlforhmicenpcSignal);
                Signal pavfcactvresplrforhmicenpcSignal;
                pavfcactvresplrforhmicenpcSignal.signalId = (int32_t)PASignal::PA_VFC_ActvReSplrForHmiCenPC;
                pavfcactvresplrforhmicenpcSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcactvresplrforhmicenpc;
                //成员赋值
                pavfcactvresplrforhmicenpc.availability = ntohl(data.pavfcactvresplrforhmicenpc.availability);
                pavfcactvresplrforhmicenpc.data = ntohl(data.pavfcactvresplrforhmicenpc.data);
                pavfcactvresplrforhmicenpc.format = ntohl(data.pavfcactvresplrforhmicenpc.format);
                pavfcactvresplrforhmicenpc.status = ntohl(data.pavfcactvresplrforhmicenpc.status);
                memcpy(pavfcactvresplrforhmicenpcSignal.value.bytes.data(),&pavfcactvresplrforhmicenpc, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcactvresplrforhmicenpcSignal);
                Signal pavfcactvresplrmgrpcSignal;
                pavfcactvresplrmgrpcSignal.signalId = (int32_t)PASignal::PA_VFC_ActvReSplrMgrPC;
                pavfcactvresplrmgrpcSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcactvresplrmgrpc;
                //成员赋值
                pavfcactvresplrmgrpc.availability = ntohl(data.pavfcactvresplrmgrpc.availability);
                pavfcactvresplrmgrpc.data = ntohl(data.pavfcactvresplrmgrpc.data);
                pavfcactvresplrmgrpc.format = ntohl(data.pavfcactvresplrmgrpc.format);
                pavfcactvresplrmgrpc.status = ntohl(data.pavfcactvresplrmgrpc.status);
                memcpy(pavfcactvresplrmgrpcSignal.value.bytes.data(),&pavfcactvresplrmgrpc, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcactvresplrmgrpcSignal);
                Signal pavfctrlrandtwbrctrlforhmicenSignal;
                pavfctrlrandtwbrctrlforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_TrlrAndTwbrCtrlForHmiCen;
                pavfctrlrandtwbrctrlforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfctrlrandtwbrctrlforhmicen;
                //成员赋值
                pavfctrlrandtwbrctrlforhmicen.availability = ntohl(data.pavfctrlrandtwbrctrlforhmicen.availability);
                pavfctrlrandtwbrctrlforhmicen.data = ntohl(data.pavfctrlrandtwbrctrlforhmicen.data);
                pavfctrlrandtwbrctrlforhmicen.format = ntohl(data.pavfctrlrandtwbrctrlforhmicen.format);
                pavfctrlrandtwbrctrlforhmicen.status = ntohl(data.pavfctrlrandtwbrctrlforhmicen.status);
                memcpy(pavfctrlrandtwbrctrlforhmicenSignal.value.bytes.data(),&pavfctrlrandtwbrctrlforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfctrlrandtwbrctrlforhmicenSignal);
                Signal pavfcseatclimaforhmicenpdcSignal;
                pavfcseatclimaforhmicenpdcSignal.signalId = (int32_t)PASignal::PA_VFC_SeatClimaForHmiCenPDC;
                pavfcseatclimaforhmicenpdcSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcseatclimaforhmicenpdc;
                //成员赋值
                pavfcseatclimaforhmicenpdc.availability = ntohl(data.pavfcseatclimaforhmicenpdc.availability);
                pavfcseatclimaforhmicenpdc.data = ntohl(data.pavfcseatclimaforhmicenpdc.data);
                pavfcseatclimaforhmicenpdc.format = ntohl(data.pavfcseatclimaforhmicenpdc.format);
                pavfcseatclimaforhmicenpdc.status = ntohl(data.pavfcseatclimaforhmicenpdc.status);
                memcpy(pavfcseatclimaforhmicenpdcSignal.value.bytes.data(),&pavfcseatclimaforhmicenpdc, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcseatclimaforhmicenpdcSignal);
                Signal pavfcsteerwhlheatgctrlforhmicenpdcSignal;
                pavfcsteerwhlheatgctrlforhmicenpdcSignal.signalId = (int32_t)PASignal::PA_VFC_SteerWhlHeatgCtrlForHmiCenPDC;
                pavfcsteerwhlheatgctrlforhmicenpdcSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsteerwhlheatgctrlforhmicenpdc;
                //成员赋值
                pavfcsteerwhlheatgctrlforhmicenpdc.availability = ntohl(data.pavfcsteerwhlheatgctrlforhmicenpdc.availability);
                pavfcsteerwhlheatgctrlforhmicenpdc.data = ntohl(data.pavfcsteerwhlheatgctrlforhmicenpdc.data);
                pavfcsteerwhlheatgctrlforhmicenpdc.format = ntohl(data.pavfcsteerwhlheatgctrlforhmicenpdc.format);
                pavfcsteerwhlheatgctrlforhmicenpdc.status = ntohl(data.pavfcsteerwhlheatgctrlforhmicenpdc.status);
                memcpy(pavfcsteerwhlheatgctrlforhmicenpdcSignal.value.bytes.data(),&pavfcsteerwhlheatgctrlforhmicenpdc, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsteerwhlheatgctrlforhmicenpdcSignal);
                Signal pavfcmmedbtnifclimateSignal;
                pavfcmmedbtnifclimateSignal.signalId = (int32_t)PASignal::PA_VFC_MmedbtnifClimate;
                pavfcmmedbtnifclimateSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcmmedbtnifclimate;
                //成员赋值
                pavfcmmedbtnifclimate.availability = ntohl(data.pavfcmmedbtnifclimate.availability);
                pavfcmmedbtnifclimate.data = ntohl(data.pavfcmmedbtnifclimate.data);
                pavfcmmedbtnifclimate.format = ntohl(data.pavfcmmedbtnifclimate.format);
                pavfcmmedbtnifclimate.status = ntohl(data.pavfcmmedbtnifclimate.status);
                memcpy(pavfcmmedbtnifclimateSignal.value.bytes.data(),&pavfcmmedbtnifclimate, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcmmedbtnifclimateSignal);
                Signal pavfcmmedbtnifseatadjustmentSignal;
                pavfcmmedbtnifseatadjustmentSignal.signalId = (int32_t)PASignal::PA_VFC_MmedbtnifSeatAdjustment;
                pavfcmmedbtnifseatadjustmentSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcmmedbtnifseatadjustment;
                //成员赋值
                pavfcmmedbtnifseatadjustment.availability = ntohl(data.pavfcmmedbtnifseatadjustment.availability);
                pavfcmmedbtnifseatadjustment.data = ntohl(data.pavfcmmedbtnifseatadjustment.data);
                pavfcmmedbtnifseatadjustment.format = ntohl(data.pavfcmmedbtnifseatadjustment.format);
                pavfcmmedbtnifseatadjustment.status = ntohl(data.pavfcmmedbtnifseatadjustment.status);
                memcpy(pavfcmmedbtnifseatadjustmentSignal.value.bytes.data(),&pavfcmmedbtnifseatadjustment, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcmmedbtnifseatadjustmentSignal);
                Signal pavfcmirrctrlfordrvrhmivisibilitySignal;
                pavfcmirrctrlfordrvrhmivisibilitySignal.signalId = (int32_t)PASignal::PA_VFC_MirrCtrlForDrvrHmiVisibility;
                pavfcmirrctrlfordrvrhmivisibilitySignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcmirrctrlfordrvrhmivisibility;
                //成员赋值
                pavfcmirrctrlfordrvrhmivisibility.availability = ntohl(data.pavfcmirrctrlfordrvrhmivisibility.availability);
                pavfcmirrctrlfordrvrhmivisibility.data = ntohl(data.pavfcmirrctrlfordrvrhmivisibility.data);
                pavfcmirrctrlfordrvrhmivisibility.format = ntohl(data.pavfcmirrctrlfordrvrhmivisibility.format);
                pavfcmirrctrlfordrvrhmivisibility.status = ntohl(data.pavfcmirrctrlfordrvrhmivisibility.status);
                memcpy(pavfcmirrctrlfordrvrhmivisibilitySignal.value.bytes.data(),&pavfcmirrctrlfordrvrhmivisibility, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcmirrctrlfordrvrhmivisibilitySignal);
                Signal pavfcprofctrlforhmicensp30sSignal;
                pavfcprofctrlforhmicensp30sSignal.signalId = (int32_t)PASignal::PA_VFC_ProfCtrlForHmiCenSP_30s;
                pavfcprofctrlforhmicensp30sSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcprofctrlforhmicensp30s;
                //成员赋值
                pavfcprofctrlforhmicensp30s.availability = ntohl(data.pavfcprofctrlforhmicensp30s.availability);
                pavfcprofctrlforhmicensp30s.data = ntohl(data.pavfcprofctrlforhmicensp30s.data);
                pavfcprofctrlforhmicensp30s.format = ntohl(data.pavfcprofctrlforhmicensp30s.format);
                pavfcprofctrlforhmicensp30s.status = ntohl(data.pavfcprofctrlforhmicensp30s.status);
                memcpy(pavfcprofctrlforhmicensp30sSignal.value.bytes.data(),&pavfcprofctrlforhmicensp30s, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcprofctrlforhmicensp30sSignal);
                Signal pavfcprofctrlforhmicensp3sSignal;
                pavfcprofctrlforhmicensp3sSignal.signalId = (int32_t)PASignal::PA_VFC_ProfCtrlForHmiCenSP_3s;
                pavfcprofctrlforhmicensp3sSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcprofctrlforhmicensp3s;
                //成员赋值
                pavfcprofctrlforhmicensp3s.availability = ntohl(data.pavfcprofctrlforhmicensp3s.availability);
                pavfcprofctrlforhmicensp3s.data = ntohl(data.pavfcprofctrlforhmicensp3s.data);
                pavfcprofctrlforhmicensp3s.format = ntohl(data.pavfcprofctrlforhmicensp3s.format);
                pavfcprofctrlforhmicensp3s.status = ntohl(data.pavfcprofctrlforhmicensp3s.status);
                memcpy(pavfcprofctrlforhmicensp3sSignal.value.bytes.data(),&pavfcprofctrlforhmicensp3s, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcprofctrlforhmicensp3sSignal);
                Signal pavfcsetproprsnlsetgSignal;
                pavfcsetproprsnlsetgSignal.signalId = (int32_t)PASignal::PA_VFC_SetProPrsnlSetg;
                pavfcsetproprsnlsetgSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetproprsnlsetg;
                //成员赋值
                pavfcsetproprsnlsetg.availability = ntohl(data.pavfcsetproprsnlsetg.availability);
                pavfcsetproprsnlsetg.data = ntohl(data.pavfcsetproprsnlsetg.data);
                pavfcsetproprsnlsetg.format = ntohl(data.pavfcsetproprsnlsetg.format);
                pavfcsetproprsnlsetg.status = ntohl(data.pavfcsetproprsnlsetg.status);
                memcpy(pavfcsetproprsnlsetgSignal.value.bytes.data(),&pavfcsetproprsnlsetg, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetproprsnlsetgSignal);
                Signal pavfcsetvehprofileSignal;
                pavfcsetvehprofileSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehProfile;
                pavfcsetvehprofileSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehprofile;
                //成员赋值
                pavfcsetvehprofile.availability = ntohl(data.pavfcsetvehprofile.availability);
                pavfcsetvehprofile.data = ntohl(data.pavfcsetvehprofile.data);
                pavfcsetvehprofile.format = ntohl(data.pavfcsetvehprofile.format);
                pavfcsetvehprofile.status = ntohl(data.pavfcsetvehprofile.status);
                memcpy(pavfcsetvehprofileSignal.value.bytes.data(),&pavfcsetvehprofile, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehprofileSignal);
                Signal pavfcdigkeyctrlforhmicenipSignal;
                pavfcdigkeyctrlforhmicenipSignal.signalId = (int32_t)PASignal::PA_VFC_DigKeyCtrlForHmiCenIP;
                pavfcdigkeyctrlforhmicenipSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcdigkeyctrlforhmicenip;
                //成员赋值
                pavfcdigkeyctrlforhmicenip.availability = ntohl(data.pavfcdigkeyctrlforhmicenip.availability);
                pavfcdigkeyctrlforhmicenip.data = ntohl(data.pavfcdigkeyctrlforhmicenip.data);
                pavfcdigkeyctrlforhmicenip.format = ntohl(data.pavfcdigkeyctrlforhmicenip.format);
                pavfcdigkeyctrlforhmicenip.status = ntohl(data.pavfcdigkeyctrlforhmicenip.status);
                memcpy(pavfcdigkeyctrlforhmicenipSignal.value.bytes.data(),&pavfcdigkeyctrlforhmicenip, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcdigkeyctrlforhmicenipSignal);
                Signal pavfcionizerairclngctrlforhmicenSignal;
                pavfcionizerairclngctrlforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_IonizerAirClngCtrlForHmiCen;
                pavfcionizerairclngctrlforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcionizerairclngctrlforhmicen;
                //成员赋值
                pavfcionizerairclngctrlforhmicen.availability = ntohl(data.pavfcionizerairclngctrlforhmicen.availability);
                pavfcionizerairclngctrlforhmicen.data = ntohl(data.pavfcionizerairclngctrlforhmicen.data);
                pavfcionizerairclngctrlforhmicen.format = ntohl(data.pavfcionizerairclngctrlforhmicen.format);
                pavfcionizerairclngctrlforhmicen.status = ntohl(data.pavfcionizerairclngctrlforhmicen.status);
                memcpy(pavfcionizerairclngctrlforhmicenSignal.value.bytes.data(),&pavfcionizerairclngctrlforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcionizerairclngctrlforhmicenSignal);
                Signal pavfcsetvehhudSignal;
                pavfcsetvehhudSignal.signalId = (int32_t)PASignal::PA_VFC_SetVehHud;
                pavfcsetvehhudSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcsetvehhud;
                //成员赋值
                pavfcsetvehhud.availability = ntohl(data.pavfcsetvehhud.availability);
                pavfcsetvehhud.data = ntohl(data.pavfcsetvehhud.data);
                pavfcsetvehhud.format = ntohl(data.pavfcsetvehhud.format);
                pavfcsetvehhud.status = ntohl(data.pavfcsetvehhud.status);
                memcpy(pavfcsetvehhudSignal.value.bytes.data(),&pavfcsetvehhud, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcsetvehhudSignal);
                Signal pavfcacchrgnforhmicenSignal;
                pavfcacchrgnforhmicenSignal.signalId = (int32_t)PASignal::PA_VFC_ACChrgnForHmiCen;
                pavfcacchrgnforhmicenSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcacchrgnforhmicen;
                //成员赋值
                pavfcacchrgnforhmicen.availability = ntohl(data.pavfcacchrgnforhmicen.availability);
                pavfcacchrgnforhmicen.data = ntohl(data.pavfcacchrgnforhmicen.data);
                pavfcacchrgnforhmicen.format = ntohl(data.pavfcacchrgnforhmicen.format);
                pavfcacchrgnforhmicen.status = ntohl(data.pavfcacchrgnforhmicen.status);
                memcpy(pavfcacchrgnforhmicenSignal.value.bytes.data(),&pavfcacchrgnforhmicen, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcacchrgnforhmicenSignal);
                Signal pavfcglobalshortotaSignal;
                pavfcglobalshortotaSignal.signalId = (int32_t)PASignal::PA_VFC_GlobalShortOTA;
                pavfcglobalshortotaSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavfcglobalshortota;
                //成员赋值
                pavfcglobalshortota.availability = ntohl(data.pavfcglobalshortota.availability);
                pavfcglobalshortota.data = ntohl(data.pavfcglobalshortota.data);
                pavfcglobalshortota.format = ntohl(data.pavfcglobalshortota.format);
                pavfcglobalshortota.status = ntohl(data.pavfcglobalshortota.status);
                memcpy(pavfcglobalshortotaSignal.value.bytes.data(),&pavfcglobalshortota, sizeof(PAIntFuncType));
                signals.emplace_back(pavfcglobalshortotaSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_VIN:{
                
                constexpr int structLen=(int)sizeof(OpVIN_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpVIN_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal pavinvinnumSignal;
                pavinvinnumSignal.signalId = (int32_t)PASignal::PA_VIN_VinNum;
                pavinvinnumSignal.value.bytes.resize(sizeof(PAStringFuncType20),0);
                PAStringFuncType20 pavinvinnum;
                //成员赋值
                pavinvinnum.availability = ntohl(data.pavinvinnum.availability);
                for(size_t i = 0;i<20;++i){
                    pavinvinnum.data[i] = data.pavinvinnum.data[i];
                }
                pavinvinnum.format = ntohl(data.pavinvinnum.format);
                pavinvinnum.status = ntohl(data.pavinvinnum.status);
                memcpy(pavinvinnumSignal.value.bytes.data(),&pavinvinnum, sizeof(PAStringFuncType20));
                signals.emplace_back(pavinvinnumSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_VINDIFFMSG:{
                
                constexpr int structLen=(int)sizeof(OpVINDiffMsg_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpVINDiffMsg_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal pavindiffmsgSignal;
                pavindiffmsgSignal.signalId = (int32_t)PASignal::PA_VINDiffMsg;
                pavindiffmsgSignal.value.bytes.resize(sizeof(PAIntFuncType),0);
                PAIntFuncType pavindiffmsg;
                //成员赋值
                pavindiffmsg.availability = ntohl(data.pavindiffmsg.availability);
                pavindiffmsg.format = ntohl(data.pavindiffmsg.format);
                pavindiffmsg.status = ntohl(data.pavindiffmsg.status);
                memcpy(pavindiffmsgSignal.value.bytes.data(),&pavindiffmsg, sizeof(PAIntFuncType));
                signals.emplace_back(pavindiffmsgSignal);
            }
            break;

            case EcarXSignalServiceID::serviceID_VPVERSION:{
                
                constexpr int structLen=(int)sizeof(OpVPVersion_Notification);
                int bufferLength=structLen;
                if (ipValue.payload_len < structLen  ) {
                    bufferLength = ipValue.payload_len;
                }
                signals.reserve(1);
                OpVPVersion_Notification data;
                memcpy(&data, ipValue.payload, bufferLength);
                
                Signal pavpversionSignal;
                pavpversionSignal.signalId = (int32_t)PASignal::PA_VP_Version;
                pavpversionSignal.value.bytes.resize(sizeof(PAStringFuncType32),0);
                PAStringFuncType32 pavpversion;
                //成员赋值
                pavpversion.availability = ntohl(data.pavpversion.availability);
                for(size_t i = 0;i<32;++i){
                    pavpversion.data[i] = data.pavpversion.data[i];
                }
                pavpversion.format = ntohl(data.pavpversion.format);
                pavpversion.status = ntohl(data.pavpversion.status);
                memcpy(pavpversionSignal.value.bytes.data(),&pavpversion, sizeof(PAStringFuncType32));
                signals.emplace_back(pavpversionSignal);
            }
            break;

        }
        return signals;
    }
}
